EveryInc/compound-engineering-plugin: Forcing AI Coding Agents to Remember

How an open-source framework replaces ad-hoc prompt engineering with a multi-agent, self-documenting software development lifecycle.

<a href="https://github.com/EveryInc/compound-engineering-plugin"> · EveryInc/compound-engineering-plugin

A vintage mechanical loom where raw, chaotic threads representing code are fed into the machine and woven into a tightly structured, permanent tapestry that feeds into a massive, organized library of punch cards. Visually represents compounding chaotic work into permanent institutional memory. — The Compound Engineering plugin weaves ephemeral AI outputs into permanent, structured codebase memory.

The key ratio: 80% planning and review, 20% execution. Most thinking happens before and after code gets written — the opposite of how most developers work.

Ry Walker Research, Research Analyst · Compound Engineering Plugin | Ry Walker Research | Ry Walker

Key Takeaways

The plugin solves LLM amnesia by forcing agents to extract bugs into a machine-readable docs/solutions/ memory bank after every fix.
Instead of a single code review prompt, it orchestrates a 14-persona adversarial pipeline to critique architecture and find failure points.
A custom TypeScript compiler acts as a Rosetta Stone, translating Claude-native Markdown skills into formats compatible with Cursor, Copilot, and Windsurf.
The framework enforces an 80/20 development philosophy, restricting AI execution until planning and review phases are explicitly approved.

The Institutional Memory Problem

Most developers use LLMs for one-off snippets. The model starts strong, loses context, and eventually breaks the build. The resulting "spaghetti AI" is a symptom of treating the agent like a junior script-kiddie with no long-term memory. The compound-engineering-plugin attacks this by introducing a command called /ce:compound.

When a bug is fixed, a "Solution Extractor" agent writes a machine-readable summary of the fix into a docs/solutions/ directory. Future planning agents read this directory before writing a single line of code. It effectively builds an institutional memory for the repository, ensuring the AI never makes the same mistake twice.

The institutional memory loop: executed code is continuously transformed into permanent repository memory.

Spawning the Adversarial Red Team

The code review process is the most technically complex part of the repository. Instead of a single chat completion, /ce:review operates as a multi-agent pipeline. It routes files to specialized "Tiered Personas."

A Ruby file goes to a simulated dhh-rails-reviewer, while critical logic is sent to an adversarial-reviewer prompted explicitly to find reasons the code will fail. This multi-lens scrutiny ensures that code is evaluated from multiple architectural and security perspectives simultaneously.

A single sheet of parchment representing a source file pinned to a table. Five distinct mechanical arms hold different types of magnifying glasses over the paper. One glass reveals structural geometry, another a glowing lock for security, and a third shows cracks representing adversarial red-teaming. Illustrates the parallel, multi-persona review pipeline. — Code review isn't a single pass; it's a parallel gauntlet of specialized, adversarial personas.

The Rosetta Stone of AI IDEs

The AI tooling landscape is fragmented across Claude Code, Cursor, Windsurf, and GitHub Copilot. The /src directory of this monorepo contains a custom TypeScript compiler that solves this fragmentation.

It takes a single Claude-native Markdown skill and cross-compiles it for over ten different AI environments, mapping proprietary tool names and environment variables automatically. This hidden superpower allows developers to author skills once and distribute them across any major AI IDE.

The 80/20 Inversion

At Every, developers manage five separate products with single-person engineering teams. Dan Shipper and Kieran Klaassen built this framework to enforce a specific operational philosophy. The AI is not trusted to write code until the /ce:plan step is explicitly approved.

WSJ hedcut-style portrait of Kieran Klaassen.

The Agent Harness Wars

The concept of an "agent harness" is dividing the developer community. As teams move beyond simple chat interfaces, the need for structured orchestration becomes paramount. We can compare the Compound Engineering approach with other popular frameworks like Superpowers and Everything Claude Code (ECC).

Framework	Core Philosophy	Architecture	Target Audience
EveryInc/compound-engineering-plugin	Institutional memory & 80/20 planning ratio	Markdown skills + cross-compiler	Small teams scaling multiple products
Superpowers (Groundy)	Strict TDD workflow	Composable markdown skills	Developers needing discipline
Everything Claude Code (ECC)	Performance optimization	JSON config + runtime hooks	Power users tweaking agents