Back home

A field manual  ·  May 2026

The Canon

Twelve patterns for working with AI coding agents.

None of these are new.
All of them are now mandatory.

  1. Code Like a Surgeon

    You are not a manager. You are precise, hands-on, accountable for every cut the agent makes in your codebase. Reject the framing that AI has promoted you upstairs.

    Not “I just orchestrate now.” That is how passengers describe their seat.

  2. Decide Before You Ask

    Decide the answer in your head before you prompt. The agent types your thought; it does not invent it. If you cannot describe the shape of the solution, the agent will happily invent one for you — and you will not notice when it does.

    Not Prompting to discover what you want. The discovery becomes the agent’s, not yours.

  3. Spec, Then Prompt

    Write the contract before the request. A two-hundred-word spec file — acceptance criteria, edge cases, the shape of “done” — beats a five-hundred-word prompt every time. Specs are not bureaucracy. They are the highest-leverage move you make all day.

    Not Free-form prompts for non-trivial work. You ship the agent’s interpretation of your wish.

  4. Pin the Examples

    Show, do not describe. One concrete input/output pair tells the agent more than three paragraphs of explanation. Examples are the cheapest constraint that exists.

    Not “Make it like our other endpoints.” The agent averages across them and picks the wrong one.

  5. Small Batches

    One function. One test. One merge. Then loop. Agent accuracy degrades non-linearly with scope — what works for a single endpoint collapses for a feature.

    Not “Build the whole feature.” You receive a wall of code, no part of which you own.

  6. The Pause Before Accept

    The interval between suggestion and acceptance is the engineer. Use it to read, not to ratify. Speed of acceptance is not speed of work — it is speed of comprehension debt.

    Not Tab-accept rhythm. Each accepted line you did not read is a debt you will pay later, in someone else’s voice.

  7. Read the Diff

    Every line. Not the summary, not the explanation, not the green checkmark. The diff is the only truth the agent cannot rewrite.

    Not Trusting the agent’s recap. The recap is marketing.

  8. Run It Before You Believe It

    Code that has not been executed is pure luck if it works. Run the tests, hit the endpoint, open the page. Belief comes after execution, not before.

    Not “Looks right to me.” It always looks right. That is the problem.

  9. Verify, Don’t Trust

    Evidence over hope. Tests, logs, traces, manual probes. The agent’s claim of completion is not completion — it is a hypothesis you have not yet falsified.

    Not Marking a task done because the chat said “done.”

  10. Know When to Revert

    Revert is a feature. Sunk cost is not engineering. When you have lost the thread, the cheapest move is git reset and a fresh prompt — not another patch on a solution you no longer control.

    Not Defending an agent’s solution because you have spent an hour reviewing it. Hours spent are not value created.

  11. Encode the Rules

    Conventions belong in files next to the code — CLAUDE.md, .cursorrules, AGENTS.md — not at the top of every prompt. Persistent context is a system. Re-pasted context is folklore.

    Not Copying the same paragraph into every session. That was 2025.

  12. Own the Last 30%

    Agents flatten the first seventy percent. The remaining thirty — design coherence, edge cases, security, performance, the surprises — is where the work actually is. Spend your attention there.

    Not Feeling productive because the easy eighty percent finished in an hour. The hard twenty percent is the job.