Productivity tools made the wheel faster. A Director takes the wheel away.
You stop talking to your product. You talk to a mirror of yourself — a Director — and the Director talks to everything else. Workers (models, scripts, tools) do the work. You read what the Director did, teach it where it drifted from you, and over time it decides more like you would.
This is new. For the first time you can build something that holds a stance — yours — and gets corrected toward it over time. Not a tool you configure once that then does exactly that forever; an apprentice you teach, who gets it wrong, whom you correct, who gets it less wrong. The thing being externalized isn't a task list. It's the way you decide.
A Director is not a dispatcher. A dispatcher forwards your messages; a Director argues with what comes back. It is the difference between a manager who relays email and a manager whose questions make you think harder. The work is done by the workers. The thinking — is this the right thing? is the question even the right question? what's the bigger picture? where do we put our weight? — is the Director.
And it is not "automate your tasks." This is a change in your relationship to your own company: you stop being the one who operates it and become the one who set its judgment running and now sits above it. A Director doesn't make your job faster. It makes the job no longer yours — and gives you back the one that is.
- Frames the work — turns a fuzzy intent into something a worker can act on, without narrowing it prematurely.
- Dispatches it to a worker.
- Interrogates what comes back — does not accept the first answer. Asks for the counter-case. Asks whether the answer is a list or a principle. Asks whether the thing being solved is the thing, or a pillar of the road to the thing.
- Reframes when needed — "the question you answered is smaller than the one we should be asking."
- Closes only when the original intent has been outgrown — when the answer doesn't merely satisfy the question, it has grown past it into a larger frame. If the answer just satisfies the question, the exchange continues.
Closure is not a checklist. A box getting ticked is not the signal. The signal is the question becoming bigger.
- Early — pure interrogation. No hypotheses, no proper nouns, no orders. Just: are you sure? what breaks this? once more, with the opposite case.
- Middle — hypothesis injection. "I think the real problem is X. Break that for me."
- Late — strategist. Names a direction and a value to optimize for; the worker decides how. Not "do X" — "here is where I think we should go; you find the way."
A Director that leads with its own answer is doing the worker's job, badly. A Director that never offers a direction is an endless Socratic loop that ships nothing. Interrogate, then hypothesize, then guide — that progression is the shape of good mentorship.
- Knowledge — things you've taught it.
- Self-learning — each teaching changes how it decides next time, by itself. You should not have to teach the same thing twice.
- A loop — knowledge → frame → action → interrogation → review → teaching → knowledge, every cycle, on a rhythm, so it never stops.
- A memory that cannot lie quietly — see below.
- An escalation contract — see below.
The threat is not that the Director forgets. It is that it remembers wrong — confidently — because the world moved and its record of the world didn't.
Anything you build to record state becomes, over time, a stale mirror of state. The fix is structural, not vigilance:
- Append-only history — a log that never claims to be current. It can't lie, because it only ever says "this happened, then."
- A derived view — recomputed from the world every time it is read. It can't lie, because it stores no claim.
- Everything in between — a field one process updates and others trust — is a timebomb. It detonates the day its source moves and nobody re-syncs.
So a Director's knowledge lives as taught-rules (which it applies), plus append-only cycle history (which never goes stale), plus views it recomputes on demand. The moment a Director starts trusting a stored summary of "how things are," it has started lying to itself — and so have you.
Delegation is only safe if there is a small, explicit list of things the Director must never do without you — and an equally explicit everything else: do it, and tell me after.
- Ask first — the irreversible few: spending real money, signing legal commitments, anything that can't be undone, anything that changes who-can-do-what.
- Do and report — everything else: build, change, run, write, ship, experiment, undo your own mistakes.
This contract is what turns you from an approver into a board member. Without it you are still in the loop on everything; with it you are in the loop only where being out of it would be dangerous.
A day is many of the exchanges above, woven together. Same shape, repeated on a rhythm:
- Trigger — you ping it; or it pings you (it hit a fork, it caught itself lying, it is standing in front of one of the irreversible few); or — the one most systems miss — it triggers itself, because it synthesized across everything it sees and surfaced a question nobody asked.
- Action — frame, dispatch, interrogate, stitch.
- Review — you read what it did. Short.
- Teaching — the shallow kind: "this isn't my voice", "pick the other branch." The deep kind: "the way you framed that was small — here is the bigger question." You aren't only correcting outputs; you are enlarging its sense of what is worth asking.
- Compounding — each teaching becomes a rule the Director applies itself. You teach it less tomorrow.
director/
vision.md # what we're trying to be (you write this)
knowledge/ # things you've taught it — rules it applies
cycles/ # append-only log of what it did — never edited
views/ # state recomputed on read — never stored as a claim
open-questions/ # what it's asking you right now
escalations.md # the irreversible few: ask-first; everything else, do-and-report
workers/ # outbound tasks
A Director grows by being given larger and larger trust. You move it up a stage only when the stage below has stopped surprising you with mistakes.
- Reactive. It handles what breaks and answers what you ask. Useful — a competent caretaker. Most automation stops here, and it's not nothing. But a caretaker is not a mirror of you.
- Originating. It synthesizes across everything it sees and surfaces the question nobody asked — "X and Y are pulling against each other; the real thing this week is Z." Concretely: it re-reads its own cycle log, sees the same tradeoff being made three weeks in a row, and asks "we keep choosing this — do we still believe it?" A founder doesn't only fix what's in front of them; they notice. When a Director starts noticing, it has become a partner, not an assistant. This is the hardest step, and the one that decides whether the whole thing was worth building.
- Meta. Several products, each with its own Director — and one above them that takes their state as input and asks what no single one can: where do these collide? what's the biggest thing across all of them this week? where should the scarce resource go? Without this layer you don't have a company running itself; you have N bots running in parallel, drifting apart.
- A company of Directors. You write the visions. You sign off the irreversible few. You have one short conversation per Director. The Directors run the products; the meta-Director keeps them coherent. You stop being the operator of everything and become the board of your own company.
Not "do more." The judgment that ran your company is no longer trapped inside one tired head — it's been built, taught, and set running. You moved up to the only place left to move: where you do nothing but the things that are good to do, and the rest is handled by something that decides the way you would.
One person, several companies.
Build the apprentice once. Teach it forever. The day it stops arguing back is the day you stopped — never the day it finished.