A Claude Code plugin marketplace featuring the Compounding Engineering plugin, adapted for .NET/C#, Python, and TypeScript development.

Run Claude and add the marketplace:

/plugin marketplace add https://github.com/relowgroup/compounding-engineering-plugin

Then install the plugin:

/plugin install compounding-engineering

Use the Claude Plugins CLI to skip the marketplace setup:

npx claude-plugins install @relowgroup/compounding-engineering-plugin/compounding-engineering

This automatically adds the marketplace and installs the plugin in a single step.

A Claude Code plugin that makes each unit of engineering work easier than the last. Transform how you plan, build, and review code using AI-powered tools that systematically improve your development workflow.

• .NET / C# - ASP.NET Core, Entity Framework Core, Clean Architecture
• Python - FastAPI, Django, LangChain, LangGraph
• TypeScript / React - React, Next.js, Node.js
• Databases - MS SQL, Entity Framework migrations
• Observability - Sentry, OpenTelemetry

Each unit of engineering work should make subsequent units of work easier—not harder.

Traditional development accumulates technical debt. Every feature adds complexity. Every change increases maintenance burden. The codebase becomes harder to work with over time.

Compounding engineering inverts this. Each feature you build:

• Documents patterns for the next feature
• Creates reusable components that accelerate future work
• Establishes conventions that reduce decision fatigue
• Codifies knowledge that compounds across the team

This plugin provides the tools to make compounding engineering practical. It transforms vague ideas into structured plans, executes those plans systematically, and ensures every change meets your quality bar before merging.

graph LR
    A[Plan<br/>Plan it out<br/>in detail] --> B[Delegate<br/>Do the work]
    B --> C[Assess<br/>Make sure<br/>it works]
    C --> D[Codify<br/>Record<br/>learnings]
    D --> A

    style A fill:#f9f,stroke:#333,stroke-width:2px
    style B fill:#bbf,stroke:#333,stroke-width:2px
    style C fill:#bfb,stroke:#333,stroke-width:2px
    style D fill:#ffb,stroke:#333,stroke-width:2px

The plugin follows a three-step workflow that makes development compound:

Use /compounding-engineering:plan to transform feature descriptions into comprehensive GitHub issues.

What it does:

• Researches your codebase to find similar patterns and conventions
• Analyzes framework documentation and best practices
• Creates detailed acceptance criteria and implementation plans
• Generates code examples that follow your existing patterns

The result: Issues that make implementation easier because they've already done the research and planning work.

Use /compounding-engineering:work to execute work plans with isolated worktrees and systematic task tracking.

What it does:

• Creates isolated git worktrees for clean development
• Breaks down plans into trackable todos
• Executes tasks systematically with continuous validation
• Runs tests and quality checks after each change

The result: Features built correctly the first time, with full test coverage and no regressions.

Use /compounding-engineering:review to perform exhaustive multi-agent code reviews.

What it does:

• Checks out your PR in an isolated worktree for deep analysis
• Runs 12+ specialized review agents in parallel (auto-detects your stack)
• Identifies security issues, performance problems, and architectural concerns
• Creates trackable todos for every finding

The result: Code that meets your quality bar and documents learnings for future work.

# Create a detailed GitHub issue from a feature description
claude /compounding-engineering:plan "Add user profile avatars with Azure Blob Storage and automatic resizing"

The command will:

1. Research how your codebase handles file uploads
2. Find similar features in your repository
3. Check framework documentation for best practices
4. Generate a complete issue with acceptance criteria, technical approach, and code examples

# Execute a plan document systematically
claude /compounding-engineering:work path/to/plan.md

The command will:

1. Create a feature branch and isolated worktree
2. Analyze the plan and create a comprehensive todo list
3. Execute each task systematically
4. Run tests after every change
5. Create a pull request when complete

# Review the latest PR
claude /compounding-engineering:review

# Review a specific PR
claude /compounding-engineering:review 123

# Review from a GitHub URL
claude /compounding-engineering:review https://github.com/user/repo/pull/123

The command will:

1. Check out the PR in an isolated worktree
2. Run stack-specific review agents in parallel:
   • .NET: kieran-csharp-reviewer, dotnet-architecture-reviewer, ms-sql-reviewer
   • Python: kieran-python-reviewer, langchain-reviewer
   • TypeScript: kieran-typescript-reviewer, julik-frontend-races-reviewer
   • All stacks: security-sentinel, performance-oracle, architecture-strategist
3. Present findings one by one for triage
4. Create todos for approved findings

The plugin includes six commands for different stages of development:

Creates detailed GitHub issues from feature descriptions. Includes research, acceptance criteria, and implementation guidance.

Executes work plans systematically with worktrees, todos, and continuous validation.

Performs exhaustive multi-agent code reviews with security, performance, and architecture analysis.

Presents findings one by one for review and converts approved items into trackable todos.

Resolves multiple todos in parallel with systematic execution and quality checks.

Generates new Claude Code commands from descriptions.

The plugin includes 27 specialized agents that provide expertise in different areas:

• kieran-csharp-reviewer: C#/.NET code review with nullable types, async/await, LINQ, DI patterns
• kieran-typescript-reviewer: TypeScript code review with type safety and best practices
• kieran-python-reviewer: Python code review with focus on clarity and conventions
• dotnet-architecture-reviewer: .NET Clean Architecture, DDD, CQRS patterns
• langchain-reviewer: LangChain/LangGraph patterns and observability
• code-simplicity-reviewer: Identifies opportunities to simplify complex code

• ms-sql-reviewer: MS SQL, EF Core migrations, query performance, indexing
• rest-api-reviewer: REST API design, OpenAPI, status codes, versioning
• data-integrity-guardian: Database design review and data consistency checks

• security-sentinel: Comprehensive security audits and vulnerability detection
• performance-oracle: Performance analysis and optimization recommendations
• sentry-investigator: Error investigation using Sentry and OpenTelemetry

• architecture-strategist: System design review and architectural guidance
• pattern-recognition-specialist: Identifies patterns and suggests improvements

• repo-research-analyst: Analyzes repository patterns and conventions
• best-practices-researcher: Researches best practices for technologies
• framework-docs-researcher: Fetches relevant framework documentation
• git-history-analyzer: Analyzes git history for context and patterns

• lint: Auto-detects stack and runs appropriate linters (dotnet format, ruff, eslint)
• every-style-editor: Edits content to match style guide
• pr-comment-resolver: Systematically resolves PR review comments

Traditional development tools help you work faster. Compounding engineering tools make future work easier.

Every /compounding-engineering:plan you create:

• Documents patterns that inform the next plan
• Establishes conventions that reduce planning time
• Builds institutional knowledge

Every /compounding-engineering:work execution:

• Creates reusable components
• Refines your testing approach
• Improves your development process

Every /compounding-engineering:review you run:

• Catches issues earlier
• Documents learnings for the team
• Raises the quality bar systematically

Over time, you're not just building features—you're building a development system that gets better with each use.

The plugin embodies these compounding engineering principles:

Prefer duplication over complexity: Simple, clear code that's easy to understand beats complex abstractions. The code reviewers enforce this strictly.

Document as you go: Every command generates documentation—issues, todos, review findings—that makes future work easier.

Quality compounds: High-quality code is easier to modify. The multi-agent review system ensures every change meets your quality bar.

Systematic beats heroic: Consistent processes beat individual heroics. The /compounding-engineering:work command executes plans systematically, with continuous validation.

Knowledge should be codified: Learnings should be captured and reused. The research agents analyze your codebase to apply your own patterns back to you.

1. Install the plugin using one of the methods above
2. Run /compounding-engineering:plan on your next feature idea
3. Use /compounding-engineering:work to execute the plan
4. Run /compounding-engineering:review before merging
5. Repeat, and watch your development process compound

Each cycle makes the next cycle easier. That's compounding engineering.