augmented-engineering

A Claude Code plugin implementing compound engineering principles — the practice of making every development session leave your tools, documentation, and automation better than you found them.

Compound engineering is a methodology developed by Dan Shipper and Kieran Klaassen at Every. This plugin provides an opinionated tooling implementation of those principles. The skills, hooks, configuration system, and multi-lens review architecture are original work by Brooks Johnson.

Most engineering work generates implicit knowledge that evaporates between sessions: patterns discovered during debugging, architectural decisions made in conversation, workflows repeated manually because nobody wrote them down. Compound engineering captures that knowledge systematically. Each session ends with a structured review that identifies what should be encoded into docs, skills, hooks, or agent instructions — so the next session starts from a higher baseline.

This plugin provides the project bootstrapping, session management, memory consolidation, code review, and auditing workflows that make compound engineering practical. It extends the superpowers plugin with five skills and four hooks.

Prerequisites

• Claude Code >= 1.0.0
• superpowers plugin (peer dependency — provides TDD, debugging, and brainstorming skills)
• jq (recommended — required for .compound.json config; hooks degrade gracefully without it)

Installation

Marketplace install

# Add the marketplace source
/plugin marketplace add Augmented-Dev72/augmented-engineering

# Install the plugin
/plugin install augmented-engineering@augmented-engineering

Team auto-install

Add to your project's .claude/settings.json so teammates get prompted automatically:

{
  "extraKnownMarketplaces": {
    "augmented-engineering": {
      "source": {
        "source": "github",
        "repo": "Augmented-Dev72/augmented-engineering"
      }
    }
  },
  "enabledPlugins": {
    "augmented-engineering@augmented-engineering": true
  }
}

Local development

# Session-only (no install, great for testing)
claude --plugin-dir ~/augmented-engineering

# Or clone to plugins directory
git clone https://github.com/Augmented-Dev72/augmented-engineering.git ~/.claude/plugins/augmented-engineering

What's Included

Skills (5)

Skill	Command	Purpose
Compound Init	/compound-init	Bootstrap compound engineering in any project — scaffolds CLAUDE.md, agents, docs, and configuration
Session Summary	/session-summary	Capture learnings to .claude/sessions/ with a structured compound step review
Consolidate Memory	/consolidate-memory	Weekly promotion of session learnings to MEMORY.md, with staleness pruning
Compound Review	/compound-review	Multi-perspective code review using 8 specialized lenses (security, performance, architecture, etc.)
Compound Audit	/compound-audit	Monthly system health check — inventory skills, hooks, docs, and identify gaps

Hooks (4)

Hook	Event	Purpose
Session Start	SessionStart	Injects compound engineering mindset reminder
Pre-Commit	PreToolUse (Bash)	Auto-prepends conventional commit emoji to git commit messages
Post-Edit	PostToolUse (Edit/Write)	Runs formatting, linting, and auto-testing based on .compound.json rules
Session Stop	Stop	Cleans temp files and prunes abandoned git worktrees

Configuration

The plugin reads project-specific configuration from .compound.json in your project root. All configuration is optional — the plugin works out of the box with sensible defaults.

{
  "postEdit": {
    "rules": [
      { "match": "\\.(js|ts)$", "run": "npx prettier --write $FILE" },
      {
        "match": "\\.(js|ts)$",
        "pathMatch": "/src/",
        "run": "npx eslint --fix $FILE"
      },
      { "match": "\\.(py)$", "run": "black $FILE" }
    ],
    "autoTest": {
      "enabled": true,
      "match": "\\.(js|ts)$",
      "excludeMatch": "__tests__|test|spec",
      "testDiscovery": "sibling-dir",
      "testDirName": "__tests__",
      "testSuffix": ".test.js",
      "testCommand": "npx jest --testPathPattern=$TEST_FILE --bail"
    }
  },
  "compoundReview": {
    "baseBranch": "main",
    "lenses": [
      "security",
      "performance",
      "architecture",
      "over-engineering",
      "error-handling",
      "test-quality",
      "data-integrity",
      "maintainability"
    ],
    "lensOverrides": {
      "security": "Also check for: SQL injection via ORM raw queries, JWT validation",
      "performance": "Also check for: missing database indexes, N+1 queries"
    }
  },
  "cleanup": {
    "tempFilePatterns": ["/tmp/compound-*"],
    "pruneWorktrees": true
  }
}

Configuration Reference

postEdit — Formatting and linting after file edits

Field	Type	Description
rules[].match	regex	File path pattern to match (applied to full path)
rules[].pathMatch	regex	Optional additional path filter
rules[].run	string	Command to run ($FILE replaced with actual path)
autoTest.enabled	boolean	Enable auto-test discovery and execution
autoTest.match	regex	Which source files trigger auto-testing
autoTest.excludeMatch	regex	Skip files matching this pattern (e.g., test files)
autoTest.testDiscovery	enum	sibling-dir, co-located, or custom
autoTest.testDirName	string	Test directory name for sibling-dir strategy
autoTest.testSuffix	string	Test file suffix pattern
autoTest.testCommand	string	Command to run ($FILE and $TEST_FILE replaced)

compoundReview — Code review configuration

Field	Type	Description
baseBranch	string	Branch to diff against (default: main)
lenses	string[]	Which review lenses to run (default: all 8)
lensOverrides.<name>	string	Additional instructions appended to a lens prompt

cleanup — Session stop cleanup

Field	Type	Description
tempFilePatterns	string[]	Glob patterns for temp files to clean (older than 2 hours)
pruneWorktrees	boolean	Auto-prune abandoned git worktrees (default: true)

Environment Variables

Variable	Default	Purpose
COMPOUND_SKIP_PRE_COMMIT	0	Set to 1 to disable emoji auto-prepend
COMPOUND_SKIP_POST_EDIT	0	Set to 1 to disable post-edit formatting/linting
COMPOUND_CONFIG_PATH	—	Override .compound.json location

Quick Start

After installing the plugin, bootstrap compound engineering in any project:

/compound-init

This scaffolds CLAUDE.md, .compound.json, agent templates, documentation structure, and recommended .gitignore entries. The skill is idempotent — it detects existing scaffolding and warns before overwriting. After scaffolding, it walks you through customizing the TODO stubs for your project.

Attribution

This plugin implements compound engineering, a methodology developed by Dan Shipper and Kieran Klaassen at Every. Their four-phase loop (Plan → Work → Review → Compound) is the philosophical foundation. The tooling implementation — config-driven hooks, multi-lens parallel review, memory consolidation system, and system auditing — is original work.

License

MIT