This piece explains how software engineering is changing in an era where AI coding agents write all the code, and introduces compound engineering — a new engineering approach developed by the Every team. Compound engineering uses AI agent learning loops to make each new feature easier to build than the last, dramatically improving development productivity. Through this article, you'll understand the core concept and four-stage loop of compound engineering, and gain insights you can apply directly.

1. The Dawn of the AI Coding Era and the Need for Compound Engineering 🚀

The Every team found themselves in a reality where AI coding agents had become so powerful that typing code by hand felt awkward. Software engineering had long been built on the assumption that coding is hard and engineers are scarce — but that bottleneck is now disappearing. Traditional practices like manually writing tests, or laboriously typing out heavily documented, human-readable code, started to feel slow and out of date.

To meet these new capabilities and shifting constraints, the Every team developed a new engineering approach called compound engineering. In traditional engineering, adding features tends to make the codebase more complex, with more edge cases and interdependencies, making the next feature harder to build. In compound engineering, the opposite is true: each feature is expected to make the next one easier to build. 🤩

This is possible because compound engineering creates learning loops for both agents and team members. Bugs, failed tests, and the aha! insights from solving problems get documented and made available for future agents to use. The codebase's complexity still grows, but so does the AI's knowledge of the codebase — making future development work faster.

The Every team runs five software products internally using this approach, each built and maintained primarily by one person. These products are used every day by thousands of people for important work. This means that with AI used properly, a single developer today can accomplish what five developers could a few years ago. All they need is a good system for harnessing the power of AI. This article gives a high-level overview of how Every executes compound engineering.

2. The Compound Engineering Loop: Four Core Stages ✨

A compound engineer orchestrates agents that plan, write code, and evaluate. The process follows a loop with these stages:

1. Plan: The agent reads the issue, researches approaches, synthesizes information, and creates a detailed implementation plan.
2. Work: The agent writes code and creates tests according to the plan.
3. Review: The engineer reviews the agent's output and the lessons learned along the way.
4. Compound: The engineer feeds the results back into the system to improve the next loop, letting the whole system learn from both successes and failures. This is where the magic happens! 💫

The Every team primarily uses Anthropic's Claude Code for compound engineering, but the approach is tool-agnostic. Other team members use Factory's Droid or OpenAI's Codex CLI. If you want to try it yourself, you can connect EveryInc's compound engineering plugin to Claude Code and run the same workflow they use internally.

Roughly 80% of compound engineering effort is focused on the Plan and Review stages, with the remaining 20% on the Work and Compound stages. Let's look at each stage in more detail.

2.1. Plan 🧠

In a world where agents write all the code, most of a developer's time is spent planning. Good planning starts with research. We have the agent look through the current codebase and its commit history to understand the codebase's structure, existing best practices, and how things are built. We also ask it to search the internet for best practices related to the problem we're trying to solve. This prepares the agent to do good work.

Once research is complete, the agent writes a plan — typically a text document in a computer file or a GitHub issue. This plan document contains everything in detail: the feature's goals, proposed architecture, specific ideas about how the code will be written, a list of research sources, and success criteria.

A planning document for a Cora feature. (Image courtesy of Kieran Klaassen.)

A plan helps build a shared mental model between you and the agent about what to build. Good planning isn't just about delegating work — it requires the developer to think deeply and exercise creativity to steer the agent in the right direction. As models improve, especially for smaller projects, you can plan less and the agent will still understand what you want, or even produce surprisingly good results. But for complex production projects, good planning is essential to building high-quality software that works as expected. With a good plan, the hard part is mostly done. 😉

2.2. Work 🛠️

This stage is genuinely simple — it's arguably the easiest step. You just tell the agent to start working. The agent takes your plan, turns it into a to-do list, and builds things step by step.

One of the most important tips for this stage is to use Model Context Protocol tools like Playwright or XcodeBuildMCP. These tools let the agent write code and test the app by using the web app or simulating use on a phone — just like a real user. 🧑‍💻 The agent writes code, inspects the app, spots issues, fixes the code, and repeats until done. This is especially useful for design work and workflows, since you can keep iterating on a prototype until it closely matches the design.

With the latest agents — models like Opus 4.5, for example — the output from the Work stage is much more likely to be functional and error-free. Especially when the plan is well-written, the result often comes out very close to what you imagined. But even good output needs to be checked — that's what the next stage is for.

2.3. Assess 🤔

In the assessment stage, we ask the agent to review its own work, and we review it alongside. This can take many forms. We use traditional development tools like linters and unit tests to catch basic errors, and manually test to confirm what was built makes common sense. We also use automated code review agents — Claude, Codex, Friday, Charlie — to spot-check the code and find common issues.

Modern AI makes the assessment stage far more powerful. For example, Every's compound engineering plugin reviews code in parallel with 12 sub-agents, each checking from a different perspective. 😮 One agent looks for common security issues, another checks for common performance problems, and another looks for over-engineering so the software doesn't become bloated or too complex. All of these different perspectives are synthesized and presented to the developer, who can then decide what to fix and what to ignore.

The true power of compound engineering is unleashed in the next stage — the one that ensures you never face the same problem twice. 💪

2.4. Compound 💰

This is where the money is! We take the lessons learned in previous stages — bugs, potential performance issues, new ways of solving specific problems — and document them so agents can use them next time. This is how the "compound" effect happens in compound engineering.

For example, in the codebase of Cora, Every's AI email assistant, before building anything new the agent is expected to ask itself: Where does this belong in the system? Should it be added to something that already exists, or does it need something new? Has a similar problem been solved before that I can reuse? 💬 These questions come with concrete technical examples drawn from past mistakes, guiding the agent to find the right solution in the right place in the codebase.

These rules are mostly built in an automated way. After finishing a code review, for instance, we'll ask the agent to look through the comments, summarize them, and save them for later use. The latest models are smart enough to do all of this without additional instruction, and smart enough to actually use it next time around! 💡

What's beautiful about this is that these learnings are automatically distributed to the team. Because they're written as prompts inside the codebase or in a plugin like Every's, every developer on the team gets them for free. Everyone becomes more productive. Even a new hire who has never touched the codebase before is just as well-equipped to avoid common mistakes as someone who has been on the team for years. 🎓

3. Compound Engineering: Looking Ahead and Learning 🔭

This has been a basic overview of compound engineering. In truth, each stage contains enough depth to be its own standalone article. There are also several constraints that still exist in this new mode of software production — such as the rate at which a developer can decide what to build, process and refine plans, and articulate what "good" looks like — that we haven't covered here.

We're only scratching the surface of compound engineering's possibilities and its broader implications. Manually writing tests, writing heavily documented human-readable code, requiring coding without internet access, expecting new hires to take weeks before committing code — none of these are necessary anymore. Nor is getting locked into a particular platform or technology because legacy code is too hard to understand and too expensive to migrate. We look forward to writing more about what this new way of engineering makes possible.

If you're interested in this topic, we strongly recommend reading other pieces from the Every team:

1. "Stop Coding and Start Planning"
2. "Teach Your AI to Think Like a Senior Engineer"
3. "My AI Had Already Fixed the Code Before I Saw It"
4. "How Every Is Harnessing the World-Changing Shift of Opus 4.5"

You can also attend workshops like Codex Camp to learn firsthand how to build with OpenAI's coding agent. The Every team plans to publish more pieces about each stage of this process and how it has transformed engineering at Every and beyond. Stay tuned! 😊

Closing Thoughts 💡

Compound engineering is an innovative approach that leverages the powerful coding capabilities of AI agents to shift the paradigm of software development. Through the four core stages — Plan, Work, Assess, and Compound — agents and developers continuously learn and improve, ultimately maximizing development efficiency and productivity. This amplifies the capabilities of individual developers, automates knowledge sharing across the team, and ultimately enables faster and more efficient software development. The Every team is confident that the future of software engineering will be led by "compound engineering" done alongside coding agents.