Skip to main content

Compound Engineering: Daily Use of the Framework

· 4 min read
Illustration of compound engineering framework in action

Most teams ship work. Great teams improve how they ship work.

That is the idea behind compound engineering: a repeatable loop that makes each task easier, safer, and faster than the last.

Plan → Work → Assess → Codify

Use this loop on every ticket—even small ones—and you will steadily reduce rework, bugs, and decision fatigue.

1) Plan​

Goal: Produce a plan you would confidently hand to a teammate.

What to do​

  • Define one small, testable objective (one feature, one bugfix, or one refactor slice).
  • Add constraints (for example: do not change API contracts, keep schema unchanged, maintain backward compatibility).
  • Specify clear acceptance criteria.

Prompt template​

  • “Scan the repo, identify relevant files, and draft a step-by-step implementation plan.”
  • “Include risks, edge cases, and a minimal test plan.”
  • “List what is explicitly out of scope.”

Output you want​

  • Ordered steps
  • Files likely to change
  • Dependencies and assumptions
  • A short test checklist
  • Open questions (ideally few)

If the plan feels vague, fix it now. Ambiguity in Plan becomes churn in Work.

2) Work​

Goal: Execute with focus and minimal thrash.

What to do​

  • Start with a clean context/session so execution follows the plan, not chat drift.
  • Provide the plan and enforce it: “Implement this plan exactly. If you must deviate, stop and explain first.”

Guardrails​

  • If clarifying questions appear, answer briefly and move on.
  • If scope expands, pause and restate acceptance criteria.
  • If complexity rises, cut scope before adding abstractions.

A strong Work phase is boring by design: predictable, incremental, and easy to review.

3) Assess​

Goal: Validate correctness from multiple angles.

Minimum checklist​

  • Behavior: Happy path plus 1–2 important edge cases.
  • Tests: Run relevant existing tests; add new tests where they increase confidence.
  • Security: Authentication, authorization boundaries, input validation.
  • Simplicity: Fewer moving parts; avoid unnecessary abstractions.
  • Consistency: Match repository patterns and conventions.

High-leverage tactic: role-based review​

Run lightweight reviews from different perspectives:

  • Security reviewer
  • Architecture reviewer
  • Simplicity/maintainability reviewer
  • Product/UX reviewer (when user-facing)

Ask each reviewer to classify findings:

  • P1 — Must fix before merge
  • P2 — Should fix soon
  • P3 — Nice to have

This creates shared severity language and prevents “everything is urgent.”

4) Codify (the compounding step)​

Goal: Convert today’s mistakes into tomorrow’s defaults.

When you notice repeatable friction, turn it into a rule instead of a reminder.

A) Always-on rules (for frequent mistakes)​

Store in a persistent project memory file (for example, CLAUDE.md):

  • Prefer one settings update tool.
  • Never edit migrations manually; use scripts.
  • When touching auth, always add unauthorized-access tests.

B) Just-in-time rules (for niche workflows)​

Write short docs that are loaded only when relevant (for example, release steps, incident playbooks, import procedures).

C) Architecture decisions (for recurring design tradeoffs)​

Create concise ADRs with:

  • Context
  • Decision
  • Consequences
  • Example

This prevents re-litigating the same decisions every sprint.

A practical starter version​

If you want a simple default you can apply today:

  1. Plan: Draft steps + a small test checklist.
  2. Work: Implement only the approved plan.
  3. Assess: Run tests + security/simplicity review.
  4. Codify: Capture one new rule in your team memory file.

Run this loop for a few weeks and compare outcomes: cycle time, escaped defects, and number of repeated mistakes.

Common failure modes​

  • Skipping Codify, so every task feels new.
  • Assessing by intuition instead of checklist.
  • Allowing scope creep during Work instead of tightening Plan.

Compound engineering is not about perfection. It is about reducing avoidable mistakes, one loop at a time.