Loop Engineering: Stop Prompting, Start Building Systems That Prompt Themselves

Boris Cherny, the creator of Claude Code, told Y Combinator that Anthropic deleted 80% of Claude Code's system prompt. The lesson is not about prompts. It is about what replaces them: loops that discover, plan, execute, verify, and iterate on their own.

Claude Code

The prompt is dying. The loop is taking over.

For three years, businesses treated AI like a very smart intern you hand a note to. You write a prompt, the model answers, you read it, you fix it, you paste it somewhere. Every run starts from zero. Every result depends on whether someone wrote the note well that morning.

That model is already obsolete, and the clearest signal came from inside Anthropic itself. In a Y Combinator talk, Boris Cherny explained that every time a new model ships, the Claude Code team deletes and rewrites large parts of the system prompt, because most of it existed only to correct behavior the model should have known but didn't. When the model got smarter, 80% of that scaffolding became dead weight. His core point for builders: the skill is no longer writing a great prompt. It is giving the model a hard task, giving it a way to verify its own work, and letting it iterate until it gets there.

That shift has a name, and I call it loop engineering: building systems that prompt themselves.

What loop engineering actually means

A static prompt is a single instruction fired once. A loop is a system that keeps working: it reads the environment, decides what to do next, acts, checks the result, and feeds what it learned back into the next cycle. The pattern that covers almost every useful agent system looks like this:

DISCOVER, then PLAN, then EXECUTE, then VERIFY, then ITERATE.

• Discover: the system reads the current state. A repo, an inbox, a spreadsheet, a dashboard, a live webpage.
• Plan: it turns that state into a concrete next step, not a guess but a decision based on what it just observed.
• Execute: it does the work with tools, not words. Edits files, calls APIs, drafts the email, updates the record.
• Verify: it checks the output the same way a human would. Runs the tests, opens the page, compares the numbers against the source.
• Iterate: if verification fails, it fixes and tries again. If it passes, the loop either ends or moves to the next task with the lesson attached.

Cherny put verification first in practice: he called it the single most important thing people get wrong. Give the model a task that is slightly too hard, give it the tools to verify the work like you would if you were doing it yourself, watch where it struggles, and fix that gap. That is the whole job.

Why this matters if you run a business

A static prompt is a cost center with a human attached. Someone has to run it, read the output, catch the mistakes, and re-run it when the inputs change. The human is the loop.

A well built loop removes the human from the cycle and keeps them at the checkpoint. The difference is where attention goes. In the first world, your team spends hours producing output. In the second, they spend minutes reviewing verified output and deciding what to do with it.

The economics are what should get a founder's attention. Token prices keep falling while model capability keeps rising, which means the same loop that was too expensive to run hourly last year is now cheap enough to run every five minutes. Cherny described exactly this shape at Anthropic: loops that run like scheduled jobs on your machine, and the same loops running in the cloud so you can close your laptop. He said the team now has Claude maintaining parts of its own tooling, live-blogging progress to a Slack channel while the engineers review the results. That is not a smarter chatbot. It is a staffing diagram with a new kind of worker on it.

Five practical steps to start

1. Pick one task you already repeat. The best first loop is not ambitious. It is something a person does weekly with a clear definition of done: a report, a sync between two systems, a monitoring check, a draft that always follows the same structure.
2. Write the verification before the prompt. Decide how a careful human would check the result. Tests, a live page check, a reconciliation against a source of truth. If you cannot describe the check, you cannot build the loop. This is the step most teams skip and regret.
3. Wire the five stages explicitly. Discover, plan, execute, verify, iterate. Name them in your design. When the loop misbehaves, you need to know which stage failed: bad inputs, a bad plan, a bad action, or a missing check.
4. Put it on a schedule and give it memory. A loop that runs once is a script. A loop that runs every morning, remembers what it learned yesterday, and only pings a human when verification fails, is staff. Cherny's framing maps directly: a local scheduled loop is a cron job for your agent, and the same thing in the cloud lets you walk away.
5. Keep a human at the gate, not in the loop. Review outputs at the checkpoint, approve the risky actions, and improve the loop when it fails. An unmanaged loop is a hobby. A managed one is an employee: monitored, maintained, supervised, and supported.

The one-page version

Static prompting treats AI like a vending machine: insert prompt, receive answer, hope for the best. Loop engineering treats it like a new hire: give it a job, the tools to check its own work, and a manager who reviews results instead of dictating keystrokes. The teams winning with AI in 2026 are not the ones with the cleverest prompts. They are the ones whose systems prompt themselves, verify themselves, and get better every time they run.

If your team is still hand-running the same prompts every week, that is not an AI strategy. It is a queue of loops waiting to be built.

About the Author

I'm Brian Marvin, an AI-native Fractional CTO with 30 years in technical leadership. At empowered.guru, I help startups build MVPs, shape roadmaps, and make AI-powered technology decisions that scale.