The bottleneck moved

By the end you can tell whether a task deserves the full loop, and you know the three habits that make it pay.

TL;DR

• Typing code is no longer the constraint; formulating the work is. Three habits carry it: domain clarity, decomposition, test evidence before "done".
• Run the full loop only when the task touches more than three files, crosses concerns, or is something you would not hand-type. Otherwise type it.
• The rigor costs a slow first month and pays back over the quarter. Start with fifteen lines, not a perfect setup.

The constraint moved

The bottleneck is no longer producing code. It is formulating the work clearly enough that the agent does exactly what is needed.

For forty years, output was limited by how fast a developer could type valid code. Autocomplete, better IDEs and AI-assisted typing all attacked that gap. An agent breaks it: in the work an agent handles well, the next hundred lines went from an hour of typing to thirty seconds of waiting. The cost is not zero, but it is no longer the constraint.

Teams that treat the agent as a code generator let it type, handle everything else as before, and spend more time fixing output than the typing saved. Teams that ship well formulate the work so the agent can execute it correctly. Vague specifications produce guessing, and guessing produces output that looks right and is not.

The people building the models agree. In July 2026 an Anthropic engineer opened a field guide to Claude Fable 5 by calling it "the first model where I find the quality of the work is bottlenecked by my ability to clarify its unknowns."

Three habits

All three are formulation, not generation.

• Domain clarity before code. The agent does not know your business, your conventions or why the codebase looks the way it does. Load that context first: AGENTS.md, skills, the research phase.
• Decomposition by file and by task. An agent will attempt a multi-file refactor in one shot, and the result is far harder to review than five coherent steps. Write the plan, execute it, verify each step.
• Test evidence before "done". The agent will say the change is complete, sincerely, and sometimes be wrong: "this looks right" is not "I ran the tests." Use behavioral tests that exercise the change. If you cannot test it that way, it probably should not have been an agent task.

The first two habits define the expected outcome; the third measures against it.

The four unknowns

Every gap in a prompt is one of four kinds of unknown, and each has a different fix.

The same guide splits the human half of formulation into four questions. The mapping onto this manual is mine, not his.

The loop test

Run the full loop if any one of three triggers is true. If none is, type it.

Formulating well is paid before the agent writes a line, and for trivial work it costs more than the agent contributes. The loop pays back when at least one holds:

• The work touches more than three files. The blast radius is large enough that an unguided agent will get something wrong.
• The change crosses concerns. Schema plus service layer plus UI, where one misstep cascades.
• You would not hand-type it. It is novel, or large, or in code you do not know well enough to write by hand.

A two-line bug fix needs no research note; a one-line config change needs no plan. Use the loop when formulating costs less than the agent getting it wrong.

Two teams, one quarter

The cost of rigor is paid in the first month; the benefit keeps paying after it.

The clearest case I have seen: two teams at the same company, in adjacent areas of the same product, using the same agent.

Team A turned the agent loose immediately and celebrated the early velocity. By month three they were shipping at roughly the pre-agent baseline, with higher defect rates and visibly drained senior reviewers.

Team B spent month one on the practice: AGENTS.md drafted and iterated, skills written for the team's patterns, hooks configured. They shipped no agent-led work that month. By month two they were back at baseline velocity. By month three they shipped at noticeably better quality and velocity than before the agent.

Discipline feels slow; the lack of it costs more, and that stays invisible until you look at cycle time across a quarter. This was a field observation, not a controlled experiment, and adjacent teams are not independent samples.

Start small

The practice does not need to be perfect to pay.

A fifteen-line AGENTS.md beats none, and a half-finished research note beats none. Teams that build the perfect workflow before running it get stuck, because there is always one more rule, skill or hook to add.

Write fifteen lines on what you know is dangerous, run a few stories through the agent, and add the rules that would have prevented the failures you saw.

When it breaks

• Looping everything, or nothing. Every task through the loop slows you down; none misses the wins. Run the loop test first.
• Judging at week four. Team B shipped no agent-led work in month one. Measure across the quarter.

Do this Monday

• [ ] Put the next task you were about to dispatch through the loop test. If no trigger fires, type it.
• [ ] If one does, write a 200-word research note before dispatching.
• [ ] Write one sentence saying what "done" means for the change, and which test will show it. No AGENTS.md yet? Write its fifteen-line skeleton too.

Go deeper

• Templates: Appendix B.2, the AGENTS.md skeleton; B.3, the six-phase loop checklist.
• Deep dive: Appendix D, Chapter 3 - the Fable 5 unknowns frame, the METR trial and its caveat, and the February to April 2026 regression.
• Sources: Appendix C.