The Director Pattern
One agent you talk to. A queue that does the work. A record that remembers.
Stop re-explaining your life to a chat window. Run one agent that files the work, hands it to runners, checks the result against the files, and briefs you every morning.
Beer Bond holder? Sign in and it is already yours.
The problem
You have an AI that can write code, draft documents, and search the web. You open a window, explain the situation, and get something useful. Then you close the window, and it is gone.
Tomorrow you explain again. Next week you find three half-finished threads on the same topic in three different tools. The agent said "done" on Tuesday and the file it described does not exist. Nothing has a due date. Nothing has a state. There is no place to look that tells you what is waiting on you.
The tooling has gotten very good at doing work inside a session. It has not gotten good at the part around the session: what to work on, whether it is finished, what happened yesterday, and what you owe it.
What this is
The Director Pattern is how I run one agent over my whole life and work. Not many agents. One. I call it the director, and it is the only thing I talk to.
- I say what I want, in the context of a project or an area of life.
- The director runs intake until it can state what "done" looks like, then files a task: a YAML file with a tenant, a context, a deliverable, acceptance checks, a due date, and a review path.
- A runner picks up ready tasks on a heartbeat and does the work inside a budget (max runtime, max turns, max spend).
- A judge reads the acceptance checks and verifies each one against the actual files. Not the runner's summary. The files.
- Tasks that pass land in review. I look, I say done, or I file a follow-up.
- Everything lands in a record: design first, decisions with their premises, a build log. Transcripts roll up into a daily facts file, a daily note, and a morning briefing at six.
I have run this every day since August 2026. It has produced several hundred filed tasks, fifty-odd written decisions, and a briefing every morning. This kit was written inside it.
What is inside
Twelve chapters, about twelve thousand words. The arc: why one director; the shape of the system; intake; the task envelope and its states; goals and re-planning with a mandatory stop rule; the judge; the record; memory layers; boundaries and tenants; setting it up in a weekend with Claude Code; what broke and what I did; and the daily running of it.
Nine templates you copy and edit: root instructions for the director, the task envelope, an intake checklist, the judge rubric, a decision-note template, the morning briefing prompt, the daily digest prompt, a weekend setup checklist, and the folder layout.
Every chapter has at least one thing you can use the same day: a rule, a template, a checklist, or a failure I hit and the fix.
Why me
I am not a researcher. I manage a technical team at a day job, I run a small studio on the side, and I have a household. I built this because I needed one system across all three and could not keep a chat history straight, let alone three.
The system is real and it is imperfect. The judge exists because agents tell you they finished when they did not. The record exists because I re-decided the same question three times before I started writing decisions down with their premises. The boundary rules exist because identifiers from my day job leaked into a transcript through a careless shell command, and I had to design a rule so it could not happen again.
What it is not
- Not a hosted product. Nothing to sign up for. Files on your machine.
- Not a prompt pack. The prompts are the smallest part.
- Not a way to avoid reviewing your own work. The review lane is the point.
- Not tied to one vendor. Claude Code is the reference tool because it is what I run. The pattern does not care.
Who should not buy
- If you want a chatbot to talk to, this is more structure than you need.
- If you will not open a terminal, the setup chapter will frustrate you.
- If you expect it to run without you reading a briefing most mornings, it will fill up with review items and stall. That is by design.
If none of those are you, the Intake Sheet is free below. Read it first. If it changes how you hand work to an agent, the rest of the kit will too.
- People who use Claude Code or a similar coding agent daily and are tired of every session starting from zero.
- One-person operators juggling a day job, a side business, and a household, who want one place where all of it is tracked without mixing the three.
- Anyone who has watched an agent say 'done' and then found nothing on disk.
- One director agent you talk to, with written instructions you own, that turns a conversation into a filed task with a due date and acceptance checks.
- A file-based task queue (draft, ready, running, review, blocked, done) that survives restarts and is readable with `cat`.
- A judge step that verifies every acceptance line against the actual files before anything reaches you, so 'done' means done.
- A memory stack that costs nothing to maintain: transcripts become a daily facts file, a daily note, and a morning briefing you actually read.
- Hard fences between your day job, your business, and your private life, enforced by a tenant tag on every task.
- 12 chapters, about 12,000 words, on the pattern as I run it: director, queue, runners, judge, record, memory, boundaries.
- 9 plain-text templates: root instructions, task envelope, intake checklist, judge rubric, decision note, briefing prompt, digest prompt, weekend setup checklist, folder layout.
- The Intake Sheet: the one-page discipline that decides whether a task is ready to run (also the free sample).
- A weekend setup path with Claude Code as the reference tool. The pattern is tool-agnostic; the commands are not, and I say where.
- A chapter on what broke in my instance and what I changed, with the rules each failure produced.
- The morning ritual: what to read, in what order, and what to ignore.
- START-HERE.md with a read order and a map of every file.
12 chapters · 9 template files · read on the site or download the zip.
The Intake Sheet
The one page that decides whether an agent is allowed to start.
- Why one director — The problem with many agents and many chat windows, and why the fix is one agent you talk to, with everything else behind it.
- The shape — Director, queue, runners, judge, record. What each one is, what each one is not allowed to do, and how they share files instead of memory.
- Intake — The conversation that turns an ask into a task. What the director always settles, when to stop asking, and how "just do it" still leaves a record.
- The task envelope and its states — One YAML file per task. Every field, what enforces it, and what each state means. Files are the truth; everything else is derived.
- Goals and re-planning — A goal is an agreement, not a task list. The director re-plans after every result inside the agreement, and stops to ask the moment a result would change it.
- The judge — Agents say they finished when they did not. The judge reads the acceptance lines and verifies each one against the files. Nothing reaches you without passing.
- The record — Design first, decisions with their premises, a build log that points back. The record is what the director reads at session start and what makes the system explainable to you in three months.
- Memory layers — Transcripts to daily facts to a daily note to a morning briefing. Four layers, one of them free, and the session-start rule that makes them get read.
- Boundaries and tenants — Your private life, your day job, and your business are three tenants. The tag on every task decides where material may live, what may touch it, and what may leave. Pointers, not content.
- Set it up in a weekend — The concrete path from an empty folder to a working loop with Claude Code: layout, root instructions, first task, first judge verdict, first briefing. Two places to swap if you use a different agent.
- What breaks and what I did about it — Nine failures from running this daily, the rule each one produced, and where the rule lives now. Your failures will be different. Write them down the same way.
- Running it — The morning ritual, the review lane, quiet hours, and the cost discipline that keeps a subscription-based system inside its window. What a normal day looks like.
Do I need to be a programmer?
You need to be comfortable in a terminal and editing text files. Everything in the kit is markdown, YAML, and shell commands. There is no application to build; the agent writes most of the glue, and the chapters tell you what to ask it for. If you have used Claude Code or Cursor for a week, you are fine.
Which AI does it need?
Any coding agent that can run from the command line with a prompt and edit files. I use Claude Code and the kit's commands assume it. The pattern (director, queue, judge, record) works with other agents; you swap the command in two places and I mark them.
How long does setup take?
A weekend to a working loop: folder layout, root instructions, first task filed, first task judged, first briefing generated. Chapter 10 is the path. Refining it is ongoing, and Chapter 11 is honest about that.
How is this different from a prompt pack?
A prompt pack gives you words to paste into a chat. This gives you a system: files on disk with defined states, a rule for when work is allowed to start, a step that checks output against files, and a record that persists. The prompts are the smallest part. The templates and the operating rules are the product.
Will this run my life for me?
No. It runs bounded tasks you defined and reports back. You review. You decide. The stop rule in Chapter 5 exists precisely so the system asks instead of guessing when the outcome, date, budget, scope, or tenant would change.
Refund?
Thirty days, no questions. Email the address on your receipt. If the kit did not give you at least one rule you now run by, I do not want your money.
The Director Pattern. $49, once.
Card through Stripe. Yours the moment it lands: read it here, download the zip, keep it. Or a Beer Bond: every deal and every product, for life.