Inspired by Darwin's theory of evolution, enabling projects to continuously adapt and evolve like living organisms.
Darwin is a Claude Code plugin that provides complete project management lifecycle support with unique self-evolution capabilities.
- Automated Evolution (
/darwin:auto-evolve): Execute N iterations of the complete lifecycle automatically, like biological evolution - Intelligent Committee Recommendation: AI analyzes each version's requirements and plan to dynamically recommend the optimal reviewer composition
- Direction-Focused Evolution: Configure evolution focus (performance / security / ux / quality) with smart role recommendations
- Self-Evolution Engine: Analyzes historical data + searches best practices = continuous improvement
- Superpowers Integration: TDD, code review, code simplification, and plan execution workflows
- Visual Dashboard: React-based project status panel with formatted document viewer
# 1. Add Darwin marketplace
/add-marketplace Darwin
# 2. Install darwin plugin
/install darwin# Clone to your plugins directory
git clone https://github.com/anon019/Darwin.git ~/.claude/plugins/darwin
# Restart Claude Code to load the plugin# 1. Initialize Darwin in your project
/darwin:init
# 2. Open the main menu
/darwin| Command | Description |
|---|---|
/darwin |
Main menu with context-aware options |
/darwin:init |
Initialize Darwin in current project |
/darwin:auto-evolve |
Automated multi-iteration evolution cycle |
/darwin:idea |
Collect and discuss requirements |
/darwin:plan |
Generate execution plan + AI committee recommendation |
/darwin:review |
Technical committee review |
/darwin:develop |
Execute development with TDD + code simplification |
/darwin:retrospective |
Version retrospective analysis |
/darwin:evolve |
Self-evolution proposal generation |
/darwin:dashboard |
Launch visual dashboard |
/darwin:config |
View/customize committee configuration |
/darwin:sync |
Sync git commits to changelog for Dashboard |
Darwin's signature capability: fully automated evolution cycles that run the complete lifecycle N times.
/darwin:auto-evolve # Single iteration
/darwin:auto-evolve -n 5 # 5 iterations
/darwin:auto-evolve -n 3 -d performance # Performance-focused evolution
/darwin:auto-evolve --resume # Resume interrupted session
/darwin:auto-evolve --dry-run # Preview mode| Parameter | Short | Description |
|---|---|---|
--iterations |
-n |
Number of iterations (1-100) |
--direction |
-d |
Focus: performance / security / ux / quality / all |
--require-approval |
Pause for user approval at requirement phase | |
--dry-run |
Preview mode, skip actual development | |
--resume |
-r |
Resume interrupted session |
--skip-committee-setup |
Skip smart committee configuration |
┌─────────────────────────────────────────────────────────────────────────┐
│ Darwin Auto-Evolve Lifecycle │
├─────────────────────────────────────────────────────────────────────────┤
│ │
│ evolve → idea → plan → review → revise → develop → code-simplify │
│ ↓ │
│ retrospective ← auto-fix ← code-review │
│ │
└─────────────────────────────────────────────────────────────────────────┘
Before iterations begin, Darwin recommends committee composition based on evolution direction:
| Direction | Add Roles | Weight Increase |
|---|---|---|
| performance | Performance Engineer, DevOps | Backend, Algorithm |
| security | Security Engineer, Compliance | Backend |
| ux | UX Researcher, Accessibility | UI, Frontend |
| quality | QA Architect, Code Reviewer | Test, Backend |
Regardless of review result (passed/conditional/rejected), Darwin:
- Absorbs all feedback into
plan-revised.md - Generates
plan-revision-notes.mddocumenting changes - Auto-passes revised plan to avoid review loops
- Proceeds directly to development
Darwin's core innovation: each version iteration dynamically configures the optimal technical committee.
After plan generation (/darwin:plan), Darwin automatically:
┌─────────────────────────────────────────────────────────────────┐
│ Intelligent Committee Recommendation │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 1. Analyze Documents │
│ └─> Scans requirement.md and plan.md │
│ Identifies key technical domains │
│ │
│ 2. Map Domains to Roles │
│ └─> Matches domains to appropriate reviewer roles │
│ Assigns weights based on domain importance │
│ │
│ 3. Generate Dynamic Roles (when needed) │
│ └─> Creates project-specific roles │
│ e.g., "Workflow Architect", "UX Engineer" │
│ │
│ 4. User Confirmation │
│ └─> One-click confirm or customize │
│ │
│ 5. Store Version Config │
│ └─> Saves to versions.{version}.committeeConfig │
│ Used by review and retrospective │
│ │
└─────────────────────────────────────────────────────────────────┘
| Priority | Source | Description |
|---|---|---|
| 1st | Version committeeConfig | AI-recommended for this version |
| 2nd | Global reviewCommittee | User-customized via /darwin:config |
| 3rd | Default 7 roles | Fallback if no configuration exists |
When users want to customize recommendations, these preset roles are available:
Core Roles: Product Manager, Frontend Engineer, Backend Engineer
Optional Roles: UI Designer, Test Engineer, Data Engineer, Algorithm Engineer, System Architect, Security Engineer, DevOps Engineer, Mobile Engineer, SRE Engineer, DBA, Technical Writer, ML Engineer
Dynamic Roles: AI generates project-specific roles based on content analysis (e.g., Workflow Architect, UX Engineer, Quantitative Expert)
Darwin's development phase (/darwin:develop) integrates a complete quality-focused workflow:
┌─────────────────────────────────────────────────────────────────┐
│ Development Workflow │
├─────────────────────────────────────────────────────────────────┤
│ │
│ 1. Brainstorming │
│ └─> superpowers:brainstorming │
│ Deep understanding of requirements │
│ │
│ 2. Plan Execution │
│ └─> superpowers:executing-plans │
│ Step-by-step execution with verification │
│ │
│ 3. Test-Driven Development (TDD) │
│ └─> superpowers:test-driven-development │
│ RED → GREEN → REFACTOR cycle │
│ │
│ 4. Verification │
│ └─> superpowers:verification-before-completion │
│ All tests pass, code meets standards │
│ │
│ 5. Code Simplification │
│ └─> code-simplifier:code-simplifier │
│ Remove redundancy, improve readability │
│ │
│ 6. Code Review │
│ └─> superpowers:requesting-code-review │
│ Final quality check before completion │
│ │
└─────────────────────────────────────────────────────────────────┘
RED → Write a failing test first
GREEN → Write minimal code to pass the test
REFACTOR → Improve code while keeping tests passing
After tests pass, Darwin automatically triggers code simplification:
- Remove duplicate code
- Simplify complex logic
- Improve naming and readability
- Reduce nesting levels
- Unify code style
The visual dashboard provides:
- Overview: Version stats, feature growth, cumulative progress
- Timeline: Version history with change summaries (+Added, ~Changed, ✓Fixed)
- Version Detail: Changelog cards, file diff view (GitHub-style)
- Document Viewer: Formatted display for review reports and retrospectives
- Reviews: Technical committee review records with radar charts
- Evolution: Proposal history and learning records
# Launch dashboard
/darwin:dashboard
# Or manually
cd ~/.claude/plugins/darwin/dashboard && npm install && npm run devDarwin stores project data in docs/darwin/ (created by /darwin:init):
docs/darwin/
├── config.json # Darwin configuration
├── versions/ # Version history
│ └── v0.1.0/
│ ├── requirement.md # Requirements document
│ ├── plan.md # Execution plan
│ ├── changelog.md # Change log
│ ├── review.json # Review records
│ ├── retrospective.json
│ └── diff.json # File changes
├── evolution/
│ ├── proposals/ # Evolution proposals
│ └── learning/
│ ├── best-practices.md
│ └── lessons-learned.md
└── metrics/
└── stats.json # Statistics
Each version stores its AI-recommended committee:
{
"versions": {
"v0.2.1": {
"committeeConfig": {
"recommendedAt": "2026-01-25T09:38:00+08:00",
"analyzedDocuments": ["requirement.md", "plan.md"],
"identifiedDomains": ["workflow automation", "config management"],
"roles": [
{ "id": "product-manager", "weight": 0.20, "reason": "..." }
],
"generatedRoles": [
{ "id": "workflow-architect", "weight": 0.25, "definition": {...} }
],
"excludedRoles": [
{ "id": "ui-designer", "reason": "No UI work in this version" }
]
}
}
}
}Darwin's core feature is self-evolution:
- Experience Collection: Analyze retrospective data from historical versions
- External Learning: Search industry best practices via WebSearch
- Proposal Generation: Synthesize internal and external knowledge
- User Decision: Present proposals for user approval
Score = w1 × frequency + w2 × impact + w3 × (1 - cost)
where w1 = 0.4, w2 = 0.4, w3 = 0.2
weighted_frequency = frequency × exp(-λ × days_since_last_mention)
where λ = 0.01 (configurable)
darwin/
├── .claude-plugin/ # Plugin configuration
│ ├── plugin.json # Plugin metadata
│ └── marketplace.json
├── skills/ # 12 skills
│ ├── darwin/ # Main menu
│ ├── init/ # Project initialization
│ ├── auto-evolve/ # Automated evolution cycles (core feature)
│ ├── idea/ # Requirements collection
│ ├── plan/ # Plan generation + committee recommendation
│ ├── review/ # Technical review
│ ├── develop/ # Development execution
│ ├── retrospective/# Version retrospective
│ ├── evolve/ # Self-evolution proposal
│ ├── config/ # Committee configuration
│ ├── dashboard/ # Visual dashboard
│ └── sync/ # Git sync to dashboard
├── roles/ # Role configurations
├── agents/ # Reviewer prompts
├── schemas/ # JSON Schema validation
├── templates/ # Document templates
├── tools/ # Utility tools
└── dashboard/ # React dashboard source
Darwin automatically responds in the user's language:
- Chinese input → Chinese response
- English input → English response
- Claude Code CLI
- Node.js 18+ (for dashboard)
- superpowers plugin (recommended)
- code-simplifier plugin (recommended)
Issues and Pull Requests are welcome!
MIT License
Darwin - Let your projects continuously evolve