Compound Engineering vs Loop Engineering

Compound engineering makes each unit of work teach the next one. Loop engineering makes a recurring job run itself. They get compared because both are cycles you run with coding agents, and because both put their leverage in what persists between runs. They answer different questions, and most serious setups end up using both. The exact phrase "compound engineering" measured about 3,600 US Google searches a month in June 2026 (Google Ads history, pulled 2026-08-24), and third-party comparisons have circulated since at least May, so here is ours.

Compound engineering is Every's term, not ours. Kieran Klaassen developed and documented it building Cora, Every's AI email assistant, and Every ships it as an open-source plugin that runs on Claude Code, Cursor and a dozen other harnesses. If you want the methodology from its authors, read their guide. This page does a different job: it puts their cycle next to the loop engineering frame we work in and marks where the two meet, where they differ, and how a compound practice feeds a loop.

What Is Compound Engineering? (Every's Definition, Not Ours)

Every's one-line premise is that each unit of engineering work should make the next unit easier, not harder. The practice is a cycle you run on every feature:

1. Plan. Turn the idea into a blueprint before any code: research, design, a written plan the agent will execute. The methodology deliberately weights this heavily; the guide's rule of thumb puts most of the effort in planning and review rather than the coding.
2. Work. The agent implements the plan. This can be fully autonomous: the plugin's /lfg command plans, implements, runs multi-agent review, applies fixes, tests, commits, pushes, opens a PR, and watches CI, hands-off. Klaassen's own phrasing in his August 2026 conference talk is to let the machine run overnight, in parallel.
3. Review. The guide's instruction is to have multiple agents review the output, then have the agent resolve findings and validate fixes. Its "beliefs to let go" list explicitly includes the belief that every line must be manually reviewed. Human judgment concentrates at the ends of the process, what Klaassen calls the human-AI sandwich: brain on when choosing what to build, brain on when applying taste to what shipped, machine in the middle.
4. Compound. The signature step: write the lessons from this cycle into files (project docs, skills, an AGENTS.md) that the next session reads automatically. The first three steps produce a feature; this one produces a system that builds features better each time. His stated discipline is a 50/50 split: half the time on the feature, half teaching the system what went wrong.

Will Larson's analysis is the cleanest outside read of why this landed: plan, work and review are patterns most agentic engineers already know, and the novel move is compound, having the agent summarize its learnings into a structured format that future planning consults. Most practitioners were already compounding by hand; Every made it a named, automatic step. Larson calls the whole thing a cheap, useful experiment you can implement in an hour, which matches our experience.

As of August 2026 the plugin is 33 skills running on 14 platforms, at 24.5k GitHub stars.

What Is Loop Engineering?

Loop engineering is designing a recurring or goal-driven process as an engineered object: a trigger (a schedule, an event, a threshold), durable state the process reads and writes, a stop condition, and a verify step that decides "good enough to continue" or "done." The whole discipline concentrates in the verifier, because a process that runs at 9am whether or not anyone is watching needs its bar written down as something executable: tests pass, the link resolves, the number moved, the schema validates. The verifier, not the model, is the bottleneck.

Our guide covers that operating model in full; this article focuses on its boundary with compound engineering.

The Actual Boundary: A Unit of Work vs an Operation

Put precisely: compound engineering organizes units of work (a feature, a fix, a document) so that knowledge accumulates across them. Loop engineering organizes operations (a recurring job, a monitored goal) so that they run without a person driving. The boundary is the shape of the job, not who is watching, because supervision is a dial in both frames: Every's pipeline runs autonomously under /lfg, and a loop can be run attended while you tune it.

	Compound engineering (Every)	Loop engineering
Coined by	Every; Kieran Klaassen, building Cora	Emerged from the unattended-agent practice; our guide documents the frame
The cycle	Plan, work, review, compound	Trigger, discover, plan, execute, verify, repeat until a stop condition
Unit	A piece of work with an end state: the feature ships	A process with a lifecycle: it recurs, or runs to a goal
What persists between cycles	Lessons files, skills, docs the next session reads	The loop's spec, state and verifier, tightened run over run
Where the bar lives	Documented standards, multi-agent review, human taste at the ends	An executable verifier, because the process runs on a schedule
Supervision	A dial: attended sessions through fully autonomous /lfg runs	A dial: attended tuning through unattended scheduled runs
Fails when	You skip the compound step and every session starts from zero	The verifier is weak and the loop ships confident garbage on a schedule

The mapping between the cycles is close but not one to one: compound planning spans a loop's discover and plan, work maps to execute, review spans verification and judgment, and the compound step maps to the loop's memory and spec updates, with repeat as the loop's own edge. Ken Huang's comparison framed compound engineering as improvement at the workflow level, lessons from each cycle feeding the next, back in May; the loop frame is what that idea becomes when the workflow itself has a schedule and a lifecycle.

Judgment vs Executable Checks: A Task Property, Not a Definition

There is a real fork here, but it runs through both frames rather than between them. Some bars can be written as a check a machine can run. Some bars are taste. That is a property of each job, and it decides how much autonomy the job can carry in either frame:

• Jobs whose bar you can write as a check can run with the human gate removed: in Every's frame that is /lfg with review skills doing the checking; in ours it is a scheduled loop with a verifier.
• Jobs whose bar is taste keep a human at the judgment points in either frame: Klaassen's sandwich ends, or a loop that stops at a review gate instead of shipping.

Writing your bar down as an executable check is the load-bearing work either way. Loop engineering just forces the question earlier, because a recurring process has to answer it before its second run.

The Compound Step Feeds the Loop

The two frames also connect in a specific, practical way: the compound step accumulates exactly what a loop needs to exist.

Watch what those lessons files contain after enough cycles: the gotchas of your codebase, the standards a change must meet, the failure modes the agent hit last time. That is a written specification of how a job is done and how to judge it done well, which is a loop's spec, memory, and bar. When a job you have been running as compound cycles turns out to recur, and the last few reviews have been a documented checklist rather than a taste call, that job can graduate: wrap the cycle in a trigger, turn the checklist into the verifier, point it at the lessons files. A well-built loop even keeps compounding after the graduation, updating its own memory each run; the strongest version, a loop that rewrites its own contract as it learns, is what our self-improving loops page covers.

For transparency, the provenance of this page is the near version of that: it was drafted by a scheduled SEO loop working from a written spec, was revised after an independent review found real errors in the first draft, and passed a human merge gate before publication. The spec and the review gate did the work; that division is the point.

Which Frame Fits Which Job? A 3-Question Sort

For any job you currently run with an agent, our recommendation:

1. Does the job recur, or run toward a measurable goal? No: it is a unit of work; run the compound cycle on it and bank the lessons. Yes: continue.
2. Can you write the bar as a check a machine can run? No: keep it in attended cycles while the compound step sharpens your documented standards; revisit when the reviews stop surprising you. Yes: continue.
3. Have the last few reviews been checklist, not taste? Yes: build the loop. Turn the checklist into the verifier, schedule the trigger, and spend your attention where judgment still earns it.

Expect the sort to move jobs over time rather than settling once: the compound step keeps converting taste into documented standards, which keeps making more jobs loop-ready. Sequencing which jobs to hand over first, and what tends to break as you grant autonomy, is the subject of how to become an AI-native company.

This page compares cycles for a single agent. When one loop is not enough and you start wiring several together, you have left both frames and entered graph territory, where every node is still a loop and the discipline compounds again at the topology level.

Compound Your Units of Work; Build Loops for Operations

Compound engineering is Every's name for making each unit of agent work teach the next one, with autonomy as a dial from attended sessions to overnight /lfg runs. Loop engineering is the design discipline for jobs that are operations rather than units: triggers, state, stop conditions, and a verifier that holds the bar when the schedule fires. Run the compound cycle on your feature work and let it write your standards down. Build loops for the jobs that recur. The lessons files from the first are the raw material for the second.

---

Related Content

• Loop Engineering: Stop Writing Prompts, Start Writing Verifiers - The operational half of this page in full: designing the cycle, writing the verifier, pinning the stop condition.
• The Evolve Loop: Loops That Rewrite Themselves - What compounding looks like inside a running loop: a process that updates its own contract.
• Graph Engineering vs Loop Engineering - The other boundary: what happens when one loop is not enough and you wire several into a graph.
• How to Become an AI-Native Company - Which jobs to hand to loops first, and what breaks at each step of granting autonomy.

---

Start Here

The compound step will write your standards down. The verifier is the skill that turns them into a job that runs without you, and it is what the Loop Engineering course teaches: design the cycle, write the verifier, pin the stop condition.

Not sure which of your jobs can graduate? Bring your task list to the AI Builder Club and we'll run the 3-question sort on it with you.

Join AI Builder Club