How a Team's AI Coding Flow Should Be Wired
A change lands in review with everything green. The rules pass, the types check, the tests are close to the ones I'd have asked for. I read the diff anyway, and the thing I'm looking for isn't in it.
A change lands in review with everything green. The rules pass, the types check, the tests are close to the ones I'd have asked for. I read the diff anyway, and the thing I'm looking for isn't in it.
The business intent, what we're accomplishing, goes in the PR description. Solved problem; we've had a text box for it since forever. The engineering intent — how it's built — I said out loud to an agent at eleven at night.
One evening an agent working in this repo killed an idea of mine for failing a rule. The kill was well argued and it cited the rule by line number, the way the standards file demands. The next morning I opened the file at that line.
The first stage of my code reviewer hands the next one a two-field object: a rule id and a citation. Not its reasoning. Not the file it just read. Two fields.
I asked an agent which of three approaches to take. It gave me three — each described accurately, tradeoffs and costs and failure modes, all of it right. And it was useless: I still had to make the decision it had just described back to me.
A good rule set grows. Mine has grown — tested against a whole corpus of real PRs and code — into something too big to hand a model all at once, and that's the scale problem Rules Are the Alpha ends on.
The reviewer is the visible product: it reads a diff, applies a rule corpus tested against real PRs and code, and ships the findings worth a person's attention.
Ask a model to summarise a document and you can hold the result against the document — the raw is right there.
I built an eval to tell me whether my agent's skills were earning their place. For a while it said they weren't — clean, green, confident.
Sixteen minutes and sixteen dollars to surface four low-severity nits, most of it spent scanning for rules rather than judging code. A corpus can fit the context window and still overflow the model's attention.
I had a figure I liked. Writing about giving the AI the why instead of the what, I'd reached for a bespoke image — mine, a little odd, exactly the shape of the thing. Then I said out loud that it might not be accurate.
I told the agent fidelity came first. It optimised for cost anyway, for an embarrassing reason — cost had an estimator and a guardrail, and fidelity had a sentence.
The goal was never a cheaper reviewer. It was finding everything that is really there while posting nothing that isn't — and that objective, not the budget, is what forced the pipeline apart.
I asked the agent to review a diff. Two skills woke up and started fighting over whose job it was. And the skill I'd built a week earlier for exactly this review? It never stirred.
You wrote a skill. It's good. Now you want it to lean on another skill — call it, require it, ship the two together so installing yours pulls in the one it depends on. So you go looking for a dependencies field.
Here's the pitch, and it's a good one. Vibe-coded slop is only the symptom; the disease underneath is context debt — the steady loss of what the code means and how its parts connect.
The AI reads from your codebase before it writes into it. Whatever's already there — your conventions, your shortcuts, your best work and your worst — is the prompt.