The Workflow That Compounds

Twenty-one thousand stars in nine months is usually the sign of a good demo. What Every Inc. shipped instead is a good habit, packaged and versioned and shipped as software. The compound-engineering plugin is the most-starred take on an idea that flips how teams think about debt: every unit of work should make the next one cheaper.

The Premise

The repo is really two products. The first is a methodology plugin: 39 skills and 43 agent personas that encode Every’s internal loop. Strategize, ideate, plan, execute, review, and then the step it’s named for, compound — write down what was learned so neither humans nor future agents have to learn it twice. The house split is 80% planning and review, 20% execution. The second is an ~8,900-line TypeScript CLI that ports the whole plugin to a dozen agent platforms from one source. That is the fragmenting-landscape problem, the one that sits a level up from any single plugin.

Each unit of engineering work should make subsequent units easier.

The Machine

The converter is a textbook transpiler. It parses the Claude-native plugin into a typed intermediate form, runs it through per-target mappers, and writes it back out with per-target writers. The mappings are explicit lookup tables rather than naming conventions, so tools, permissions, hooks, and model aliases each get a deliberate translation. Installs don’t clobber anything: removed artifacts move to timestamped backups, and existing configs are deep-merged instead of overwritten.

The piece worth stealing is ce-code-review. Fourteen reviewer personas get picked by reading the diff, not by matching keywords. Confidence anchors gate the output and hide anything the reviewer scores below 75. Autofix classes draw a deliberate line between what a machine may apply on its own and what a human has to sign off. Underneath all of it runs a memory loop: a solved problem becomes a YAML-frontmatter “Learning” that later reviews find grep-first. The repo already carries 31 of its own.

The Test Drive

We ran the plugin’s own test suite: 1,669 of its 1,678 tests passed in fourteen seconds. The nine that didn’t all need live GitHub access the sandbox blocks, and not one was a real defect. Then we ran a live conversion of the actual plugin to OpenCode, Codex, and Gemini. It went through, with one skill correctly held back by platform filtering. The sharpest result was a small one: a reviewer persona written as model: inherit came out on OpenCode carrying an inferred temperature: 0.1. That is the mapper reasoning about the target, not copying bytes across.

The Fine Print

The security scan came back about as clean as scans get. Two runtime dependencies. No dynamic code execution, and no network calls at runtime beyond git. Path-traversal hardening that CI actually tests for. The one thing to keep an eye on is which global config roots get written when you convert to every target at once.

The evidence is testimony, not measurement — the single biggest gap.

The Playbook

The afternoon play is the converter. If your team is scattered across agent platforms, compile the plugin (or your own) to all of them and let the lookup tables carry the translation. On our bench a live conversion to OpenCode, Codex, and Gemini went through with real remapping, down to that inferred temperature on a model: inherit persona. Process fragmentation is a tax every multi-agent team pays, and this is the first tool we’ve tested that hands part of it back.

The weekend play is theft. You don’t have to adopt Every’s whole methodology to take ce-code-review apart and keep the good bolts: reviewer selection by judgment instead of keywords, confidence gates that hide anything below an explicit score, autofix classes that draw the automation line on purpose. Its test suite passed 1,669 of 1,678 on our bench in fourteen seconds, so the machinery is real. Rebuild those three ideas in your own harness and you’ve captured most of the value without asking anyone to change how they work.

The sprint play is the bank. Switch on the Learnings loop, feed it your first ten solved problems, and come back in a quarter with one question: is review starting to cite them? That is the experiment Every itself hasn’t run in public. The compounding is the whole pitch, the evidence for it so far is testimony, and your own before-and-after would be the first hard measurement anyone has. However that lands, the discipline underneath is the real takeaway: treat prompts as compiled, tested, versioned source, and it travels even if you never install the plugin.