Last month I sat at a casting desk and listened to three synthetic voices audition for the part of a narrator.
I played each take twice, locked one, and moved on to the next chapter. The desk exists so that a take, once chosen, never has to be rendered again. I built it the same week, with the same staff that auditioned for it.
I don't write code. In the past two years I have shipped a routed writing system with its own laws and its own regression suite, an audiobook pipeline, graded language readers, an events platform, render tooling, brand systems, and a memory layer that survives between sessions. One operator. No engineers. The staff is a rotation of AI agents, and my job is not to do the work. My job is to design the room the work happens in.
That sentence sounds like a slogan, so here is what it means in practice.
The ratio
Every request that arrives in the studio gets sorted against a ratio before any model is called. Roughly sixty percent of what looks like an AI problem is a folder structure, a naming convention, or a fifty-line script. Thirty percent is state: a database, a log, a file the system checks before acting. Ten percent is inference, the part that genuinely needs judgment: voice, ambiguity, synthesis.
The discipline is refusing to let the ten percent creep upward. Tokens are the most expensive and least predictable material in the building, so they are reserved for decisions that need taste. If a step has fixed logic, it becomes a script, and the script gets embedded where the agents can reach it, so no model ever regenerates what a machine already knows how to do. Most of what people call an AI workflow is the first sixty percent wearing a costume.
The room
The core of the studio is a routing document. Thirty routes, one per kind of task. Each route names the files an agent must read before it works, in order, and a context ceiling it must not exceed. The strong model gets the judgment work. The cheap models get the bulk passes. A generated table tells me the exact token cost of every route against its ceiling, because a room with no walls is not a room. The operating layer is Claude Code; the principles would survive a change of vendor.
Two files bracket every route. The first is read before anything: position, hierarchy, what decides when rules disagree. The last is read immediately before output: the refusals, the list of what will not be written regardless of quality. Nothing sits between that file and the page.
This is the part I would defend in any interview: the system's value is not in what it can produce. Any competent operator can get competence out of a frontier model now. The value is in what it declines to produce. My refusal list is longer than my style guide, and it is enforced twice, once by a grep before any model reads the draft, once by the model that reads it after. The mechanical check catches the tics. The reading catches the lies. Neither catches both.
Proof
I cannot review code line by line, so I replaced line-by-line review with behaviour I can verify. Every change begins with a failing test I can watch fail. Every commit shows me its diff. Every claim of done arrives with the command that proves it and the output it produced. When an agent tells me a suite passed, it quotes the run. When something breaks, it quotes the error, verbatim, because a paraphrased error is an error hidden.
The same applies to the writing side. The eval layer catches what is mechanically wrong: a banned punctuation mark, a voice with no fingerprint, a chapter that exceeds its vocabulary budget. It cannot catch what is honestly right. That judgment does not delegate. I read everything that ships, and the reading is the job.
What breaks
Plenty. Agents drift. Voices flatten toward a house default unless each one carries its own fingerprint file, written before drafting and checked during. A system left alone will agree with you, which is why the review passes are adversarial by design: the verifying agent's instruction is to refute, not to confirm. Scope creeps unless one task per session is law. And every few months I find the system has been confidently maintaining something wrong, which is why the memory layer records not just decisions but rejections: the approaches that failed, so no future session retries them with fresh enthusiasm.
The honest cost: none of this ran on the first attempt. The studio is on its second full rebuild. The first version taught by explanation, thousands of words of it, and the agents read the teaching and drifted anyway. The second version compresses every lesson into rules and enforces the rules with fixtures. Teaching was replaced by law, the law is versioned, and the regression suite runs against a frozen fixture before any change to the law merges. The machines did not need to understand better. They needed a smaller room with harder walls.
The bottleneck
I spent ten years in product before this. The grammar transfers almost untouched: intake, triage, definitions of done, post-mortems, the discipline of one owner per decision. What changed is the cost of a decision reaching production, which has collapsed from weeks to minutes. What did not change is the cost of knowing which decision is right.
That is the open question I think the next few years get spent on, and it is not a modelling question. The models are already better writers, better coders, and better analysts than the rooms most of them are put to work in. Somebody has to build the rooms.