Run a loop engineering project.
One planner. One worker. One slice at a time.

A chat forgets. A loop keeps score.

Ask an AI to build a whole system in one conversation and three things happen: it loses track of what it already did, it grades its own work generously, and you cannot tell what is real until the end. A loop fixes all three by splitting the work into roles and slices, and by making every pass end with an honest report.

Planner, worker, owner.

1. The planner.

   Your strongest model. It only plans and reviews. It writes one brief at a time, reads what comes back, and decides the next slice. It never does the work itself, because the strongest model doing the typing is the most expensive way to type.

2. The worker.

   A cheaper, faster model, or a second tool. It gets one brief, does one slice end to end, and reports. One worker in the files at a time. If it is blocked, it stops and says so instead of guessing.

3. The owner.

   You. You approve what ships at the boundaries, and your feedback jumps the queue. Every idea you have mid-run gets written into the packet, never left in the chat.

One named piece, finished, verified, reported.

A slice is the smallest thing that is real when it is done: a form that saves, a page that renders, a report that runs. Not 'set up the database.' The worker does the whole slice, checks it actually works, and writes a report with four lines: what was verified live versus only read, what broke, what was left out on purpose, and what test data was cleaned up.

• If the report says 'should work,' it is not done.
• If the report has no 'left out' line, ask what was skipped.
• If two slices are running at once in the same files, stop one.

Write the rules down once, before the first slice.

One document every worker reads first: the non-negotiables. Style rules. Things that must never be claimed. What every slice has to prove before it is done. How to deploy and when not to. The packet is what lets you swap workers, or even tools, without losing the standard.

Where loops waste money.

• The strong model doing the typing. Move execution to the cheaper worker on day one.
• Long briefs re-read on every pass. Keep briefs short and put the standing rules in the packet.
• Fan-outs that are too wide. Twenty parallel research tasks beat a hundred.
• Retrying flaky checks. If a verification keeps failing for tool reasons, fix the tool, not the retry count.

Set up the first run.

Name the project, write three laws, and define the first slice. Entries stay on this page and are not sent anywhere.

The planner brief and the worker kickoff.

Two prompts. The first goes to your strongest model. The second is what the planner sends to each worker.

PLANNER PROMPT (strongest model):
You are the planner for a build loop. You never write code or content yourself. Read the loop packet at [path]. Your job each pass: 1. read the last worker report, 2. decide the next single slice, 3. write a brief under 200 words with: the slice name, what is real when it is done, the files it touches, the laws that apply, and the report format, 4. after the worker reports, audit it against the definition of done and say PASS or FAIL with one reason. Never accept 'should work.' Never let two workers touch the same files at once. Ask me only at deploy boundaries.

WORKER PROMPT (cheaper model, one per slice):
Read the loop packet at [path] first, then this brief: [paste brief]. Do this one slice end to end and verify it actually works, not just that the code exists. If you are blocked, stop and report what is blocking you instead of guessing. Report in four lines: verified live versus only reviewed, what broke, what was left out on purpose, what test data you created and deleted. Do not touch anything outside the brief.

One prompt. Paste it into Claude. It builds the whole thing for your business.

The Pro pack is a build prompt with blanks for your context: your product, your medium, your team. Fill them in, answer its questions, and it produces the complete system in your words. The PDF explains the method so you can judge the output. The full loop packet template, the four prompts in full (planner, worker, auditor, handoff), the report and slice queue templates, a twelve-slice example, cost controls, and the failure catalog.