The idea of Compound engineering is simple: build so that every unit of work makes the next one easier instead of harder. Most codebases rot, each feature becomes a negotiation with the last one, and the system gets slower to change over time. Compound engineering inverts that. Features teach the system. A fixed bug eliminates a whole category of future bugs. Over time the work gets easier, not harder.
Kieran Klaassen and the team at Every, who named it, were explicit that the principles don't stop at engineering. They extend to design, research, even writing — any discipline where codifying taste and context makes future work faster. That's a generous invitation, this is me taking them up on it.
Because design needs this more than engineering does. And design has no name for it yet.
Let's start with how design usually works
Every campaign starts semi-fresh. Aesthetic knowledge is trapped in a few senior heads. Taste is implicit, felt, not written down. Winning patterns are weakly encoded, if at all. Teams repeat discovery work they've already done. Brand systems drift. Research gets forgotten the quarter after it's commissioned. And testing, the part that tells you whether any of it worked, happens after launch, when feedback is slowest and most expensive to act on.
This isn't a process problem, it's an architecture problem. Design, as practiced, is anti-compound. Each cycle discards most of what it learns.
Engineering already crossed this gap. It went from debugging production systems to CI/CD, from learning in the live environment to catching problems before they ship. Design is still doing market discovery. Still learning what works after the world has already seen it.
Compound design
A practice where every creative decision, test, and critique compounds into organizational perceptual intelligence, so a company gets measurably better at anticipating how audiences see, feel, and respond, with each cycle.
Compound engineering compounds operational knowledge. Compound design compounds perceptual knowledge.
Engineering accumulates knowing-how: how this system behaves, how to build in it safely. Design accumulates knowing-who: how an audience attends, what earns trust, what reads as clear, what converts. Both compound, but they compound different things.
The five layers of compound design
First, encoded taste. A normal design org keeps taste in senior creatives' heads and transfers it by osmosis, in critique. That doesn't scale and it doesn't survive turnover. Compound design externalizes it, not as a style guide, which tells you the hex code, but as operationalized judgment: visual heuristics, failure patterns, the brand tensions you keep renegotiating, the emotional targets that landed, the reason a thing worked. The hard part was always that encoding this cost more than it saved, but the math has changed.
Second, design as accumulated context. Engineering compounds because code persists. Design historically doesn't, because its outputs are episodic. A deck is presented and filed. A landing page ships and dies. A moodboard evaporates. Compound design requires persistent memory of the things that actually matter: what audiences ignored, what created attention, what signaled trust, what emotional sequencing worked, what failed and for whom. Design becomes a continuously trained layer of organizational cognition instead of a series of disposable artifacts.
Third, recursive tooling. This is the part that didn't exist before. Using agents you can now critique a layout, compare it against historical winners, flag brand drift, simulate how an audience will perceive it, generate variants, and explain the likely failure modes. This creates the missing loop: design work produces structured learning, which becomes reusable intelligence, which makes the next design better. The same flywheel engineering found.
Fourth, pre-launch optimization. This may be the defining operational layer. The historical sequence is design → launch → feedback. Compound design shifts the feedback left: design → predictive evaluation → simulated iteration → launch. Post-launch learning is slow and expensive. If engineering's leap was from production debugging to CI/CD, design's is from market discovery to pre-flight cognitive testing.
Fifth, organizational memory. The deepest version. A compound design org doesn't just make assets faster. It develops institutional aesthetic intelligence — it gets better at perceiving its audience, faster at aligning emotion and function, more coherent across channels, more capable with less coordination. That's design as an appreciating asset. Not design as labor. Design as capital.
Is it defensible?
Here's the three best arguments against it.
Design is culturally unstable. Engineering compounds because logic and physics hold still. Design sits on fashion, culture, emotion, context: what worked last year can fail next year. So compound design can't mean rigid reuse. It has to mean compounding adaptive judgment, which is a harder thing to encode.
Novelty matters. Pure optimization converges. You already see it everywhere: LinkedIn posts that read identically, SaaS landing pages that are the same page, AI branding that shares one face, short-form video with a single rhythm. A compounding system, pointed carelessly, has no room for originality. This is the real danger.
Design contains irreducible intuition. Not every breakthrough comes from accumulation. Some come from rupture, a move no historical pattern would have predicted. Over-systematize and you trap creativity.
These shouldn't be ignored, but they don't kill the idea either, they just change its shape.
Compound design is not the compounding of assets. It is the compounding of aesthetic judgment, audience understanding, and creative leverage.
Judgment adapts when culture moves, it knows when to break the pattern and is the thing worth accumulating.
Reliability versus adaptive originality
Which points at the one place compound design and compound engineering are genuinely different.
Engineering optimizes for reliability. That's the right target for code, the same input should produce the same trustworthy output every time. Convergence is a feature.
In design, convergence is how good ideas die. The moment a compound system optimizes purely for "what worked before," it marches every output toward sameness, and you get the sea of homogeneity we're all already drowning in.
So the targets of each differ:
Compound engineering optimizes for reliability. Compound design optimizes for adaptive originality.
This shouldn't be a footnote, it's how the system should be designed. A compound design practice that copies engineering's objective function will build a very efficient machine for producing forgettable work. The objective has to be judgment that stays original as the world changes, which also happens to be the thing AI is worst at alone, and what humans are the best at.
The obvious objection
A fair skeptic will say this is design systems, CRO, brand governance, and research repositories with a new word on top.
While it's partly true that the pieces aren't new, teams have built style guides, optimized conversion, governed brands, and filed research for years. If that's all compound design was, it wouldn't deserve a name.
The new ingredient is one thing: AI-mediated recursive learning. Agents that remember across cycles, critique against history, benchmark, synthesize, and transfer lessons from one context to another. That capability did not meaningfully exist until recently. It's what turns a pile of disconnected practices into a loop that actually compounds.
The name isn't the innovation. The loop is.
Intent → Make → Predict → Critique → Codify → Compound
It's the same shape as the engineering version: ideate, plan, work, review, compound, with one design-native difference that we'll get to.
Intent. Before anything gets made we need to name the target, not the deliverable, the effect. Who is this for? What should they notice first? What should it make them feel? What should it make them do? Most design skips straight to making and inherits its goals implicitly from whoever's loudest in the room. Intent is cheap to write and expensive to skip.
Make. Produce the work, the variants, the directions, the comps, together: both human and agents. Generating options is no longer where the leverage is.
Predict. Before launch, test what the work will actually do: where attention lands, what reads as clear, what feels trustworthy, which variant earns the response Intent asked for. This is the step that hasn't traditionally existed at a usable cost. It's the design analogue of continuous integration, you catch the failure before the market does, not after.
Critique. Judge the work against encoded taste and the historical record. Not "do I like it," but "how does this compare to what's worked, where is the brand drifting, what's the likely failure mode." Agents make this continuous instead of occasional, the senior eye is available every cycle, not just in the Thursday review session.
Codify. Capture why. Why this worked, why that didn't, which audience reacted how. Not a finished asset but a reusable lesson. Everyone skips this step, and it's the entire reason design doesn't compound.
Compound. Feed what Codify produced back in, so the next Intent starts smarter. The loop closes. What you learned this cycle is available next cycle, to you, the team, and the agents, without anyone having to remember to look it up.
The hero and the engine
Predict is the step that feels new, and it's the one people will associate most with compound design. But Predict alone is just better testing. The compounding lives in Codify → Compound. Predict tells you what happened. Codify → Compound makes sure you never have to learn it twice.
This is the same lesson engineering learned: the gains aren't in the work step, they're in the compound step. The work produces a thing, the compound step produces a system that makes the next thing better.
Where is your org, actually?
- Fresh every time. Taste lives in heads. Every project restarts discovery.
- Documented. A style guide. Static reference, no judgment captured.
- Systematized. A living design system. Reusable components, but the why is still implicit.
- Encoded taste. Critique agents, pattern libraries, catalogued failure modes. The system holds judgment, not just assets.
- Shift-left. Pre-launch prediction sits inside the loop. You learn before you ship.
- Perceptual intelligence. The system measurably improves at reading audiences every cycle. Design as appreciating capital.
Most teams sit at 1–2 and assume that's the ceiling. The compounding doesn't begin until 3, until the system holds judgment, not just artifacts.
Where do you start?
Don't try to build Stage 5. Build the smallest loop that compounds once, then again.
- Write one encoded-taste doc. Pick a single design decision your team keeps re-litigating. Write the judgment down: the principle, two examples that nailed it, two that missed, and why. That's a Codify artifact. You now have one.
- Stand up one critique agent. Point it at that doc and your historical winners, and let it review the next thing you make. It will be wrong sometimes — correct it, and add the correction to the doc. That's Compound, working.
- Add one Predict gate. Put a single pre-launch evaluation in front of one high-stakes surface before it ships. (At EyeQuant this is precisely the bet we made — predicting attention and clarity before publication, so the loop closes before the market sees the work instead of after. It's one worked instance of the Predict step, not the only way to build it.)
One taste doc, one agent, one gate. That's the whole method at small scale. Run it and you're at Stage 3 with a clear path to 4.
Why compound design matters
The loop isn't specific to pixels. If you run brand, growth, content, or research, you have the same problem: episodic outputs, implicit judgment, feedback that arrives too late, and the same loop fits. It works anywhere taste and audience response are the scarce inputs.
And the scarcity is the point. AI compresses the value of execution across every discipline at once. When anyone can generate a competent layout, a competent paragraph, a competent function, competence stops being the differentiator. What stays scarce is judgment, taste, memory, and orchestration, the things that decide which competent output is the right one.
Compound design is a theory about how taste becomes infrastructure. How the perceptual knowledge that used to live and die inside individuals becomes something an organization owns and grows. Engineering is learning to compound its operational knowledge. Design can compound its perceptual knowledge. In an AI-native company, those two loops eventually merge: product, brand, growth, and research feeding one system that gets better at understanding the people it's built for.
With compound design, design stops being the thing you redo every quarter and becomes the thing that's worth more every quarter.
Most teams will keep treating design as labor. The ones that treat it as capital will accelerate.