Treat AI agents like a product team and give them roles

Ask an agent whether its work is finished and it says yes, and it means it. The same agent planned the work, built it and checked it, so one set of assumptions ran all three jobs.

That costs more than a wrong answer. A mistake that came from an assumption can't be found by the one holding the assumption, so it passes every check the agent runs on itself, and you find it later, after more work has been built on top of it.

A product team solved this long ago by splitting the jobs between people. The person who checks the work didn't do the work, so they can't check it against the same wrong assumption that caused the mistake. You learn it the first time you hand finished work to a new session, a fresh conversation with the agent, that didn't build it and it finds things the builder called fine. That split is the part that transfers to agents, and how to check an agent's work without reading its code is in Judge your AI agent's work by using it, not by reading the code.

The planner says what done means

Without one, the agent picks the scope itself and picks generously. You ask for a settings page and you get a settings page, a preferences system and a data migration. All of it works, and none of it is reviewable, because nothing says what it was supposed to be.

Start with taking the solution apart if you think the stated problem isn't the real one, or getting more ideas out if the shape isn't settled. Decide what you're building before your agent decides for you turns the decision into requirements. Then /furnace-plan writes the plan and has a reviewer who never saw it being written check it before anything gets built.

The reviewer didn't build it, and that's the whole job

An author checking their own work catches typos and misses the structural problem, because the structural problem came from an assumption they're still making. Everything a reviewer is worth comes from not having made the thing.

So the reviewer is a separate session that can't see how the work was made, and can't see what you were hoping for either. Anthropic's "Building effective agents" calls a writer and a separate judge working in a loop the evaluator-optimizer pattern. Keeping the judge blind to how the work was made is what makes it worth having.

/furnace-plan does it for a plan. Run the decision past a council of five does it for a decision, and explains why one agent playing several parts can't grade its own answers. Find what's wrong with a decision while it's still cheap to change does it for something you already want to do.

QA is a program, not an opinion

A team doesn't take a builder's word that the work is finished. An agent has nothing outside itself to measure its own work against.

So write the checks that matter as small programs that pass or fail. Write AGENTS.md rules that survive the session turns a correction into one.

The art director holds the standard

This is the job that doesn't delegate, because the art director is you. It means knowing what good looks like here, saying why a particular output isn't it, and writing that down so the answer holds next time.

Teach the AI with examples a person actually wrote is how you hand over your standard instead of hoping for one. Mine somebody else's work for the parts your project can use is how you borrow someone else's from a repo or an article without reading the whole thing.

The producer keeps the record

It's the least glamorous job, and the other four depend on it. Nothing survives from one session to the next except what's written into the project.

• Stop your AI agent from forgetting your project between sessions is the file set.
• Document what happened in your session before you and the AI forget is the routine that reads and writes it.
• Capture a stray idea without leaving the task you're on stops a stray thought costing you your place.
• Drop anything into one inbox and let an agent file it where it belongs sorts what you captured.
• Give your AI a map of your files instead of the whole pile and Stop at half the context window keep the reading cheap and a long session inside what the agent can hold at once.
• Dictate the thinking and let the AI write the document gets what's in your head into the record.

What you get and what you don't

You get a map of which recipe covers which job. You don't get a technique of your own, and the art director's job stays with you. Start with the reviewer, because it costs one new conversation.

Next time an agent finishes something real, close that conversation and open a new one, so nothing about how the work was made carries over. Give it the work and the standard it should be judged against, and nothing about what you were trying to do.

Then count how many of the things it finds were called fine by the session that wrote them.