Coding agents changed the cost of producing a diff. They did nothing to the cost of deciding whether that diff belongs in the system. That second cost is now the whole job.
I read Andy Grove's High Output Management around the time I started leaning on agents heavily, and it reframed the work for me. Grove's line is that a manager's output is the output of the team they manage, plus the teams they influence. I don't measure myself by the code I type. I measure myself by what the system I designed and reviewed produced — and by how little of it I had to throw away.
That only works if bad work gets rejected fast. The repository has to supply the review structure.
The plan comes first
My attention is the scarce resource, so I spend it on the plan and the review, not on the typing.
The plan comes first, and it comes before any agent touches code. I want it solid enough that the work can't quietly cause a regression: what changes, what must not change, and how we'll know. Then the agents execute against it. This is the step people skip, and it's the one that separates real leverage from a tidy pile of plausible guesses.
A task needs a contract
“Improve the backend” is not a task an agent can execute responsibly. A useful task has a bounded scope, an observable acceptance condition, and a list of changes that are out of bounds.
type AgentWorkPacket = {
objective: string;
allowedFiles: string[];
forbiddenChanges: string[];
invariants: string[];
acceptanceCommand: string;
definitionOfDone: string[];
};For example, a good packet might say:
Objective: reject expired queue admissions.
Allowed files: coordinator.ts, coordinator.test.ts.
Forbidden changes: protocol names, D1 schema, client reducer.
Invariant: an admission can be consumed at most once.
Acceptance: pnpm vitest run coordinator.test.ts.
Done: test covers expired, reused, and session-mismatched admissions.The detail isn't bureaucracy. It gives the agent a small search space and gives me a way to decide whether the result is actually complete.
Treat generated work like a compiler pipeline
The safe loop is closer to compilation than conversation:
flowchart LR
Design["Define invariant"] --> Packet["Create work packet"]
Packet --> Agent["Agent produces diff"]
Agent --> Review["Review scope and design"]
Review --> Focused["Run focused test"]
Focused --> Quality["Run repository checks"]
Quality --> Commit["Keep a small change"]
Focused -. failure .-> Debug["Trace broken invariant"]
Debug --> PacketThe agent produces a candidate change. The repository decides whether the candidate satisfies the contract. A passing test is necessary but not sufficient — scope review is what catches the change that technically works while weakening a boundary or widening the permission surface.
TDD is how I close the loop
Tests are the thing that lets an agent check its own work. A failing test I wrote is a far better instruction than a paragraph of intent: it's concrete, it's binary, and the agent can run it as many times as it needs without me in the loop. Write the invariant down as a test first, and the whole exchange gets tighter.
For a content or schema change:
pnpm exec vitest run src/lib/__tests__/content-schema.test.ts
pnpm exec astro checkFor a behavior change:
- Write the failing test for the invariant.
- Ask the agent to implement only that behavior.
- Run the focused test and read the diff.
- Run the broader quality gate before keeping the change.
The point of the focused test isn't ceremony. It shortens the feedback loop so a wrong assumption gets caught while the task context is still small.
Types make the task legible
Types don't prevent bad design, but they make the design visible to both me and the agent. In a stateful product, a discriminated union beats a bag of nullable fields. Exhaustive matching can turn an unhandled transition into a compile-time failure, and tests can name the transition instead of asserting on incidental fields.
The one thing agents are reliably bad at
Models over-build. Ask for a solution and you'll get layers of abstraction and configuration for problems you don't have, delivered so fluently it reads like good engineering. It has never been this cheap to generate a large, clever answer that becomes a maintenance problem six months later.
So the scarce skill flipped. Anyone can generate 500 lines now. Knowing which 50 to keep is the actual work — and it's judgment the model doesn't have. KISS is the principle I push hardest in review, precisely because it's the one the tools fight.
Where agents genuinely help
They're strong around stable boundaries:
- adding adapters behind an existing interface
- expanding tests for a known state transition
- tracing a failure to its first broken invariant
- producing a first pass over repetitive content or code
- checking route behavior against an explicit contract
- generating migrations with a stated rollback plan
They're much weaker at choosing the boundary itself. “Add AI to this workflow” isn't an implementation task, because it leaves the authority, the state, and the evaluation model unspecified.
In SuperSquad, a run has a clear shape: an immutable snapshot, a browser session, journeys, evidence artifacts, finding candidates, and a terminal result. That makes the mechanical work delegable. Deciding which object owns each responsibility stays human design work.
The failure mode is false velocity
The dangerous output of agent-assisted development isn't an obvious syntax error. It's a plausible change that expands scope, duplicates authority, weakens a security check, or makes a state transition implicit.
Fast generation increases the number of changes a system can absorb. It does not increase the system's tolerance for ambiguity. So the rule I hold is simple: an agent's output isn't privileged. It passes the contract, the tests, and the design review, or it doesn't enter the codebase.
That keeps the repository from becoming a collection of unreviewed guesses.