This article explains how software engineering is evolving in an era where AI coding agents write all the code, and introduces compound engineering — a new approach developed by the Every team. Compound engineering leverages AI agent learning loops so that each new feature development becomes easier over time, dramatically improving development productivity. Through this article, you can understand the core concepts and four-step loop of compound engineering, and gain insights to apply it yourself.
1. The Dawn of AI Coding and the Need for Compound Engineering
The Every team faced the reality that AI coding agents have become so powerful that manually typing code feels awkward. Traditional software engineering evolved under the premise that coding was hard and engineer talent was scarce — but now these bottlenecks are disappearing. Manually writing tests, painstakingly typing well-documented human-readable code — these traditional approaches started feeling too slow and outdated.
To respond to these new capabilities and changing constraints, the Every team developed compound engineering. In traditional engineering, each added feature increases code complexity — more edge cases, more interdependencies — making the next feature harder. But 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 a learning loop for agents and team members. Bugs, failed tests, and aha! insights from problem-solving get documented and leveraged by future agents. Code complexity still grows, but AI's knowledge of the codebase grows alongside it, making future work faster.
The Every team runs 5 software products internally using this approach, with each product primarily built and maintained by one person. These products are used daily by thousands of people for important work. If AI is properly leveraged, one developer today can do the work of five developers from a few years ago. They just need good systems to harness AI's power.
2. The Compound Engineering Loop: Four Core Steps
A compound engineer orchestrates agents that plan, write code, and evaluate. The process follows this loop:
- Plan: The agent reads the issue, researches approaches, synthesizes information, and creates a detailed implementation plan.
- Work: The agent writes code and creates tests according to the plan.
- Review: The engineer reviews the agent's output and lessons learned along the way.
- Compound: The engineer feeds results back into the system to improve the next loop, making the entire system learn from 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 to run the same workflow they use internally.
Roughly 80% of compound engineering focuses on the plan and review stages, with the remaining 20% on work and compound.
2.1. Plan
In a world where agents write all the code, most developer time goes into planning. Good plans start with research. We have agents examine the current codebase and its commit history to understand architecture, existing best practices, and how things are built. We also ask them to find best practices on the internet related to the problem being solved. This prepares the agent to do good work.
After research, the agent writes a plan — usually a text document as a computer file or GitHub issue. It contains everything: the feature's goals, proposed architecture, specific ideas for code implementation, research source lists, and success criteria.
A planning document for a Cora feature. (Image courtesy of Kieran Klaassen)
Plans help form a shared mental model between you and the agent about what to build. Good plans aren't just about delegation — the developer must think deeply and creatively to guide the agent in the right direction. As models improve, especially for small projects, less planning may be needed. But for complex production projects, good plans are essential for building quality software that works as expected. With a good plan, the hard part is mostly done.
2.2. Work
This step is straightforward — simply tell the agent to start working. The agent takes your plan, converts it into a to-do list, and builds step by step.
One key tip is using Model Context Protocols like Playwright or XcodeBuildMCP. These tools let agents use web apps or simulate phone usage while writing code and testing the app — like a real user! The agent writes code, looks at the app, spots problems, fixes the code, and repeats until done. This is especially useful for design work and workflows, allowing continuous iteration until the prototype matches the design.
Latest agents like Opus 4.5 produce results in the work step that are much more functional and error-free. Especially with well-written plans, the output often closely matches what you envisioned. But even good output needs verification — that happens in the next step.
2.3. Assess
In the assessment step, we ask the agent to review its own work, and we also review it together. This takes various forms. We use traditional development tools like linters and unit tests for basic errors, manually test to ensure what's built makes common sense, and use automated code review agents like Claude, Codex, Friday, and Charlie to spot check code for common issues.
Latest AI makes the assessment step much more powerful. For example, Every's compound engineering plugin reviews code in parallel with 12 auxiliary agents, each checking from a different perspective. One agent looks for common security issues, another checks for common performance problems, another looks for over-engineering to keep software from becoming bloated or overly complex. All these diverse perspectives are synthesized and presented to the developer, who decides what to fix and what to ignore.
The true power of compound engineering comes in the next step — ensuring the same problem never happens again!
2.4. Compound
This is where the money is! We record learnings from previous steps — bugs, potential performance issues, new approaches to solving specific problems — so agents can use them next time. This is how the 'compounding' effect works.
For example, in Every's AI email assistant Cora codebase, before building something new, the agent must ask itself: Where should this live in the system? Should it be added to something existing, or does it need something new? Have we solved a similar problem before that we can reuse? These questions include specific technical examples 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. For example, after completing a code review, we ask the agent to examine the comments, summarize them, and save them for later use. Latest models are smart enough to do all this without additional instruction, and smart enough to actually leverage it next time!
The beautiful thing is that these learnings are automatically deployed to the team. Because they're recorded as prompts inside the codebase or in tools like Every's plugin, every developer on the team gets them for free. Everyone becomes more productive. Even a new hire who's never touched the codebase is just as well-prepared to avoid common mistakes as someone who's been on the team for a long time.
3. Compound Engineering: Looking Ahead and Learning
This has been a basic overview of compound engineering. Each step actually has enough depth to be its own standalone article. There are also constraints that still exist in this new mode of software production — like the speed at which developers decide what to build, process and refine plans, and explain what 'good' looks like — that we haven't yet covered.
We're still only scratching the surface of compound engineering's possibilities and broader implications. Manually writing tests, writing documentation-heavy human-readable code, requiring coding without internet access, expecting new hires to take weeks before committing code, and being locked into specific platforms because legacy code is too complex and expensive to migrate — none of these will be major problems anymore. We look forward to writing more about what this new engineering approach makes possible.
If this topic interests you, we highly recommend reading other articles from the Every team:
- "Stop Coding and Start Planning"
- "Teach Your AI to Think Like a Senior Engineer"
- "My AI Had Already Fixed the Code Before I Saw It"
- "How Every Is Harnessing the World-Changing Shift of Opus 4.5"
You can also participate in workshops like Codex Camp to learn hands-on about building with OpenAI's coding agent. The Every team plans to publish more articles about each step of this process and how it's transformed engineering at Every and beyond. Stay tuned!
In Closing
Compound engineering is a revolutionary approach that leverages the powerful coding capabilities of AI agents to shift the paradigm of software development. Through four core steps — plan, work, assess, and compound — agents and developers continuously learn and improve, ultimately maximizing development efficiency and productivity. This amplifies individual developer capabilities, automates team-wide knowledge sharing, and ultimately enables faster, more efficient software development. The Every team is confident that compound engineering will lead the future of software engineering.