tumf

Posted on Feb 2 • Originally published at blog.tumf.dev

Compound Engineering: Transforming Technical Debt into Technical Assets with the 80:20 Rule

#ai #devops #github

Originally published on 2026-01-31
Original article (Japanese): Compound Engineering: 技術的負債を「技術的資産」に変える80:20の法則

Every, which operates the tech/business media platform Every, has released the Compound Engineering Plugin, a plugin for Claude Code, an AI coding assistant for terminal use developed by Anthropic.

"It’s a common belief that the codebase becomes more complex with every feature added." However, the Compound Engineering Plugin turns this notion on its head. It employs a development methodology that creates the seemingly contradictory state where "the more features you add, the easier development becomes."

In this article, we will explain the meaning of the core principle of Compound Engineering: "Plan/Review 80%, Implementation 20%" and how it transforms technical debt into assets.

What is Compound Engineering?

Compound Engineering is a software development methodology practiced by Every in the age of AI agents. Traditionally, it was believed that "the more code you write, the more complexity increases," but Compound Engineering achieves a reversal where "the more code you write, the easier the next development becomes."

Traditional Development vs. Compound Engineering

Traditional Development:

Feature Addition → Increased Complexity → Slower Next Development
Accumulation of Technical Debt
Code Review aimed at "Problem Discovery"

Compound Engineering:

Feature Addition → Knowledge Accumulation → Faster Next Development
Accumulation of Technical Assets
Code Review functions as a "Learning Opportunity"

The difference is created by a four-step loop: Plan → Work → Review → Compound.

The 80:20 Rule: Why is Implementation Only 20%?

The most distinctive feature of Compound Engineering is the reversal of time allocation.

Plan: 40%
Review: 40%
Work: 15%
Compound: 5%

In traditional development, the common allocation was "80% Implementation, 20% Other." Why is implementation only 20% in Compound Engineering?

The Cost Reversal Brought by AI Agents

The answer is simple. In the era of AI writing code, the cost of writing code has dramatically decreased.

Traditional Development (human writing code):

Code Writing: Difficult and time-consuming
Planning: Relatively easy
Review: Time-consuming, but not as much as implementation

AI Era Development (AI writing code):

Code Writing: Easy and fast (handled by AI)
Planning: Difficult and important (handled by humans)
Review: Difficult and important (handled by humans)

In other words, the bottleneck has shifted from "code writing" to "planning and quality management."

Plan: Why Spend 40% of Time on Planning?

In Compound Engineering, the planning phase takes the most time. Specifically, the following steps are taken.

1. Research Phase

The AI agent is tasked with investigating the following:

Codebase Analysis: Existing code structure, naming conventions, design patterns
Git History Analysis: Learning from past changes
External Best Practices: Researching official documentation and industry standards

# Example of Compound Engineering Plugin
/workflows:plan "Implementing a new feature"

This command automatically executes the following:

Analyzes the existing code of the project
Researches best practices for related technologies
Generates an implementation plan
Clarifies ambiguous requirements through Interactive Q&A

2. Interactive Q&A Phase (added in v2.27.0)

After generating the plan, the AI poses up to five questions:

Confirmation of ambiguous requirements
Handling of edge cases
Confirmation of technical options

Example:

Q1: Is user authentication acceptable using JWT, or should we use session-based authentication?
Q2: How many retry attempts should be set for errors?
Q3: Should database indexes be created automatically?

This question phase allows for filling in specification gaps before implementation.

3. Deepening the Plan

If a more detailed plan is needed, the /deepen-plan command can be used to enhance the plan:

/deepen-plan docs/plans/2025-01-15-feature-plan.md

This command activates parallel research agents for each section of the plan, adding:

Best practices and industry patterns
Performance optimization suggestions
UI/UX improvement ideas (if applicable)
Considerations for quality improvement and edge cases
Implementation examples

As a result, a production-ready plan including implementation-level details is completed.

Work: Completing Implementation in 15% of the Time

If the plan is sufficiently detailed, the implementation phase can be completed in an astonishingly short time.

Parallel Development with Git Worktree

The Compound Engineering Plugin utilizes Git Worktree to enable parallel development:

/workflows:work docs/plans/2025-01-15-feature-plan.md

The execution of this command includes:

Creating a new Git Worktree (without disrupting existing work)
Sequentially executing the checklist from the plan
Incremental commits for each task (not batch commits)
Branch protection checks (preventing direct commits to the main branch)

Important Change (v2.27.0): Previously, all tasks were committed together after completion, but now commits are made immediately for each task. This allows for:

Progress visualization
No loss of work if interrupted
Easier reviews

Automatic Update of Checkboxes in the Plan File

During implementation, the AI agent automatically updates the checkboxes in the plan file:

Before Implementation:

## Task List
- [ ] Create database schema
- [ ] Implement API endpoint
- [ ] Add test code

After Implementation:

## Task List
- [x] Create database schema
- [x] Implement API endpoint
- [x] Add test code

This allows the planning document to function as a living progress management tool.

Review: Balancing Quality and Learning in 40% of the Time

The review phase aims not just at "bug discovery," but at creating learning opportunities.

Multi-faceted Review System

The Compound Engineering Plugin includes 14 types of specialized review agents:

Agent	Review Focus
`dhh-rails-reviewer`	Compliance with DHH (Ruby on Rails founder) style
`kieran-rails-reviewer`	Every's Rails conventions
`security-sentinel`	Security vulnerabilities
`performance-oracle`	Performance optimization
`data-integrity-guardian`	Data integrity
`architecture-strategist`	Architectural compliance
`code-simplicity-reviewer`	Simplicity and maintainability
`julik-frontend-races-reviewer`	Frontend race conditions

By executing these agents in parallel, a multi-faceted review can be completed quickly:

/workflows:review

Automatic Reflection of Review Comments

Remarkably, the AI agent learns from past review comments and preemptively fixes similar issues.

Example (from Every's blog):

"Changed variable naming to match pattern from PR #234, removed excessive test coverage per feedback on PR #219, added error handling similar to approved approach in PR #241."

In other words, the AI automatically executed the following:

Applied the naming conventions pointed out in the review of PR #234
Applied the criteria that indicated "excessive testing" from PR #219
Applied the error handling pattern approved in PR #241

Before the human reviewer opens the review, the AI has already applied past learnings.

Compound: Turning Knowledge into Assets in 5% of the Time

The final step is the "Compound" phase, which gives Compound Engineering its name.

Persistence of Learning

The following information is recorded in a reusable form:

Bugs and their fixes
Performance issues and optimization methods
New problem-solving patterns
Insights gained from reviews

These are saved in the following formats:

CLAUDE.md: Project-specific rules
Skills: Reusable knowledge modules
Agents: Definitions of specialized reviewers
Commands: Automated workflows

Example of the Compound Effect

First Implementation:

Planning: 4 hours
Implementation: 2 hours
Review: 3 hours
Total: 9 hours

Tenth Implementation (same pattern):

Planning: 1 hour (referring to past plans)
Implementation: 1 hour (pattern established)
Review: 0.5 hours (AI preemptively fixed issues)
Total: 2.5 hours

This results in a time reduction to less than one-third. This is the "compound effect."

Practical Example: Learning and Applying DHH Style

The Compound Engineering Plugin includes the dhh-rails-style skill, which has learned the coding style of DHH (David Heinemeier Hansson), the founder of Ruby on Rails.

What DHH Avoids

This skill defines patterns that 37signals (DHH's company) intentionally avoids:

Patterns to Avoid:

Service Objects (excessive abstraction of business logic)
Form Objects (form-specific objects)
Decorators (separation of display logic)
CSS Preprocessors (Sass, Less, etc.)
React/Vue (frontend frameworks)

Instead, Use:

Rails standard features (ActiveRecord, Controller)
Turbo (Hotwire)
Stimulus (lightweight JavaScript)
Standard CSS

Example of AI Applying DHH Style

Before (before AI correction):

# Service Object pattern (to be avoided in DHH style)
class UserRegistrationService
  def call(params)
    user = User.new(params)
    user.save!
    send_welcome_email(user)
  end
end

After (after AI automatic correction):

# Standard Rails pattern (DHH style)
class UsersController < ApplicationController
  def create
    @user = User.new(user_params)
    if @user.save
      UserMailer.welcome(@user).deliver_later
      redirect_to @user
    else
      render :new
    end
  end
end

The AI reads the dhh-rails-style skill and automatically corrects the code to DHH style before the code review.

Every's Achievements: One Person Operating Five Products

The effectiveness of Compound Engineering is evidenced by Every's achievements:

Five software products operated in-house
Each product managed by one person
Thousands of users using them daily
In production, not just demos

Whereas traditional development methods required five engineers for one product, now one person can manage five products. This means productivity has increased by 25 times.

How to Use the Compound Engineering Plugin

To try out Compound Engineering, install the plugin on Claude Code.

Installation

# Install the plugin on Claude Code
/plugin marketplace add https://github.com/EveryInc/compound-engineering-plugin
/plugin install compound-engineering

Basic Workflow

# 1. Create a plan
/workflows:plan "Adding user authentication feature"

# 2. Deepen the plan (optional)
/deepen-plan docs/plans/2025-01-15-auth-plan.md

# 3. Implementation
/workflows:work docs/plans/2025-01-15-auth-plan.md

# 4. Review
/workflows:review

# 5. Compound knowledge
/workflows:compound

Available Components

The plugin includes the following:

27 agents: Specialized reviewers and researchers
20 commands: Workflow automation
14 skills: Reusable knowledge modules
1 MCP server: Context7 (framework documentation search)

OpenCode / Codex Support (Experimental)

The Compound Engineering Plugin has begun to support AI coding tools other than Claude Code.

Conversion Tools

# Convert to OpenCode format
bunx @every-env/compound-plugin install compound-engineering --to opencode

# Convert to Codex format
bunx @every-env/compound-plugin install compound-engineering --to codex

This opens up the possibility of sharing agent definitions across AI coding tools.

Output Locations:

OpenCode: ~/.opencode/
Codex: ~/.codex/prompts/, ~/.codex/skills/

However, these are experimental features and may change as the formats of each tool evolve.

Conclusion

Compound Engineering represents a fundamental shift in development methodologies in the age of AI agents: