Stop fixing the output. Fix the loop.

Every time an AI agent gets something wrong, you have two options: fix the output, or fix the process that produced it. Most people fix the output. They correct the code by hand, merge it, and meet the same mistake again next week. The correction dies with the diff, and they stay the bottleneck of everything the agent produces.

The people building these tools have stopped working that way. Boris Cherny, head of Claude Code, and Peter Steinberger, creator of OpenClaw, both wrote that they barely write prompts anymore. They spend their time improving the loops their agents run in. As Peter puts it:

Here’s your monthly reminder that you shouldn’t be prompting coding agents anymore. You should be designing loops that prompt your agents.

Peter Steinberger

Satya Nadella, Microsoft’s CEO, described the company of the future as a mix of human capital and token capital: people and AI systems working together to encode workflows, domain knowledge, and judgment into loops that improve with each use.

Three people, three vantage points, one message. I’ve written before about how AI-assisted coding is a higher-level abstraction . This is what happens as that shift spreads beyond programming: the work stops being about the artifact and starts being about the process that produces it.

Fix the loop, not the output

In a regular development process, a person writes code and produces an artifact: a function, a feature, a whole program. The focus stays on the deliverable. Increasingly, the deliverable is the least interesting part.

With AI, the path to the artifact becomes repeatable, and anything repeatable can be improved. You encode your knowledge and technical decisions into the harness: skills that shape how code is written, tools that give agents capabilities they lack. Every improvement to that process raises the accuracy of everything the agent produces from then on. Advanced users already spend more time iterating on skills and workflows than reviewing generated code.

I noticed this shift in my own projects when I stopped correcting the same mistake twice. My agent kept reaching for a deprecated internal API. Instead of fixing the call sites again, I added two lines to a skill explaining what replaced it and why. It hasn’t happened since. The fix in the diff would have died with the branch. The fix in the loop outlives it.

When the output is wrong, the fix is rarely “edit the output”. It’s to edit the loop that produced it, so the next hundred outputs come out right.

flowchart LR
	Requirements --> Plan
	Plan --> Implementation
	Implementation --> Tests
	Tests --> Review
	Review --> Artifact
	Review --> Requirements

Any process with a feedback signal can become a loop

Companies are starting to notice that loops can crystallize knowledge and processes far from code. Take a marketing team. It could run a loop that produces campaigns and ads, measured against a clear KPI such as conversions. The team stops working on each individual campaign and starts optimizing the process that generates them, keeping the high-level strategy decisions for itself. Like in code, the implementation details stay with the AI.

Choose the KPI carefully, though. A loop optimizing raw views will happily flood the internet with slop (a bad loop compounds garbage exactly as efficiently as a good loop compounds quality). Deciding where human review is needed and the judgment about what to measure is what I mean by working at a new abstraction level.

Loop improvements compound

Every change you make to a loop keeps paying off from that point on. The longer a loop runs and evolves, the better its output gets.

I already see it in my codebases. The longer one lives with evolving skills, documented business decisions, and refined docs, the more accurate a coding agent becomes inside it. I worry less about each individual output because the loop’s accuracy keeps climbing. Each small change raises the quality of everything that comes after it. That’s compound interest.

Start the clock early

We still lack the tools and methodologies for working at this abstraction level, which means the processes worth building can’t be copied from anywhere. They have to be rethought from first principles: imagine what your craft could look like when the loop is the product, and build the infrastructure to get there.

The sooner you shift attention from the artifact to the loop, the longer the compounding runs. That’s already an advantage today. Projected forward, the gap only widens. Start experimenting now, the compounding has already begun.