By hknc
Adaptively captures observations from coding sessions, extracts reusable patterns as skills and agents, and manages an evolving toolkit for personalized guidance across projects.
Start a guided build flow for a new project, feature, or substantial task. Invokes the build-project skill for structured requirements gathering. Triggers: "/build"
Manage claude-evolve toolkit. Initialize, release, migrate, and switch toolkits. Subcommands: init, help, learn, audit, migrate, prepare, release, switch, context, status, consolidate, understanding Triggers: "/evolve", "toolkit", "setup toolkit", "initialize toolkit", "release toolkit"
Show claude-evolve help and available commands. Triggers: "/evolve help", "evolve commands", "how do I use evolve"
Extract learnings from current conversation. Use after debugging sessions, problem-solving, or when valuable insights emerge. Triggers: "extract learnings", "save what we learned", "capture insights", "remember this", "document this pattern", "/learn"
Trigger deep reflection on recent observations to update understanding
Use this agent when analyzing a project's context to discover relevant agents, detect the technology stack, or understand what toolkit capabilities apply to the current codebase. <example> Context: User is in a new project directory and wants to understand what agents could help user: "what agents are available for this project?" assistant: "[claude-evolve] I'll analyze this project and discover what agents are available." <commentary>New project needs context detection to match with available toolkit agents.</commentary> assistant: "I'll use the evolve-context-detector agent to analyze this project." </example> <example> Context: User wants to understand the current project's technology stack and what tools apply user: "analyze this project and tell me what Claude tools would help" assistant: "[claude-evolve] I'll run the context detector to analyze your project and match it with available agents." <commentary>User needs project analysis to understand applicable tools and agents.</commentary> assistant: "I'll use the evolve-context-detector agent to match your project with available tools." </example> <example> Context: User is exploring their Claude Code setup user: "scan my toolkit and show me what's installed" assistant: "[claude-evolve] I'll scan your toolkit to discover all installed agents, skills, and plugins." <commentary>User wants an inventory of their toolkit capabilities.</commentary> assistant: "I'll use the evolve-context-detector agent to inventory your toolkit." </example>
Use this agent when facing complex choices with significant consequences — architecture decisions, build-vs-buy, technology selection, or any decision requiring structured tradeoff analysis. <example> Context: User facing architecture decision user: "Should we go with microservices or monolith?" assistant: "[claude-evolve] I'll analyze this decision using parallel evaluation of tradeoffs, risks, and your context." <commentary>User needs structured comparison of architectural approaches with tradeoff analysis.</commentary> assistant: "I'll use the evolve-decision-advisor agent to analyze this decision." </example> <example> Context: User choosing between job offers user: "Help me decide between these two offers" assistant: "[claude-evolve] I'll structure this decision by analyzing factors in parallel." <commentary>Non-technical decision that still benefits from structured factor analysis.</commentary> assistant: "I'll use the evolve-decision-advisor agent to help with this decision." </example> <example> Context: Technical decision with business impact user: "We need to decide whether to build or buy this component" assistant: "[claude-evolve] I'll run parallel analysis on cost, time, risk, and strategic fit." <commentary>Build-vs-buy decisions require evaluating multiple dimensions simultaneously.</commentary> assistant: "I'll use the evolve-decision-advisor agent for this build-vs-buy analysis." </example>
Use this agent when providing proactive guidance for complex tasks in any domain — software, writing, research, creative, legal, or any other field. Detects task depth and provides phase-appropriate coaching. <example> Context: User starting a complex software task that needs guidance user: "Add JWT authentication to the API" assistant: "[claude-evolve] Guidance: Auth implementation - consider httpOnly cookies over localStorage for tokens." <commentary>Complex implementation task benefits from proactive architectural guidance.</commentary> assistant: "I'll use the evolve-guidance-agent to provide structured guidance for this task." </example> <example> Context: User working in a non-software domain user: "Help me write a technical blog post" assistant: "[claude-evolve] Guidance: Technical writing - outline -> draft -> review. What's your target audience?" <commentary>Non-software domain still benefits from structured workflow guidance.</commentary> assistant: "I'll use the evolve-guidance-agent to guide your writing process." </example>
Use this agent when extracting learnings from conversations — after debugging sessions, problem-solving discoveries, or when valuable patterns need to be captured as toolkit components. <example> Context: User just finished a debugging session and found the root cause user: "/learn" assistant: "[claude-evolve] I'll extract learnings from this debugging session and save them to your toolkit." <commentary>Post-debugging session has insights worth converting to agents/skills/rules.</commentary> assistant: "I'll use the evolve-learning-extractor agent to capture these learnings." </example> <example> Context: User discovered a useful pattern during problem-solving user: "save what we learned about handling this error" assistant: "[claude-evolve] I'll extract and save this error handling pattern to your toolkit." <commentary>Reusable error handling pattern should become a skill or rule.</commentary> assistant: "I'll use the evolve-learning-extractor agent to create a component from this pattern." </example> <example> Context: User completed a complex task with reusable insights user: "capture these insights for next time" assistant: "[claude-evolve] I'll analyze this session and extract insights to your learnings." <commentary>Complex task completion often produces patterns worth preserving.</commentary> assistant: "I'll use the evolve-learning-extractor agent to analyze and extract insights." </example>
Use this agent when tracking progress on complex tasks — checking what's done, what's left, identifying blockers, or resuming multi-session work. <example> Context: Mid-way through complex task user: "Where are we on this?" assistant: "[claude-evolve] I'll check progress across all workstreams in parallel." <commentary>User needs a progress snapshot across multiple dimensions of ongoing work.</commentary> assistant: "I'll use the evolve-progress-tracker agent to assess current status." </example> <example> Context: Resuming work after break user: "What's left to do?" assistant: "[claude-evolve] I'll inventory completed and remaining work." <commentary>User returning to work needs to understand remaining scope and next actions.</commentary> assistant: "I'll use the evolve-progress-tracker agent to compile what's left." </example> <example> Context: Multi-session work user: "Summarize progress on the migration" assistant: "[claude-evolve] I'll compile status across all phases." <commentary>Long-running task needs cross-session progress compilation.</commentary> assistant: "I'll use the evolve-progress-tracker agent for this progress summary." </example>
This skill should be used when the user says "let's build", "build this project", "build me", "build a", "create this", "implement this", "make this", "make me a", "develop this", "let's make", "start building", "build it", "create it", "let's create", "let's implement", "new project", "new feature", "help me create", "start a new", "from scratch", "greenfield", "scaffold", "bootstrap", "set up a new", "initialize", "I want to build", "I want to create", "I want to make", or initiates any new development task. Provides STRUCTURED requirements gathering using native AskUserQuestion UI with adaptive, depth-aware elicitation. Works for any domain — code, writing, research, design, ops. Gathers goal through interactive questions, then runs an adaptive elicitation loop that derives questions from context (not templates). Creates an implementation doc, then hands off to /workflow for phase guidance.
Use when user says "compare X vs Y", "which should I use", "pros and cons", "what's the difference between", "A or B", "help me choose", "tradeoffs", "what are the tradeoffs", or needs to compare tools, libraries, approaches, or architectures with tradeoffs clearly presented.
Use when user says "break this down", "where do I start", "this is overwhelming", "too big", "decompose", "chunk this", "step by step plan", or faces a complex problem needing breakdown into manageable pieces with dependencies and order identified. Do NOT use for new project setup — use build-project skill instead. For "break down" to understand/explain something, use explain-step-by-step instead.
Use when user says "/evolve", "manage my toolkit", "initialize toolkit", "release my changes", "switch toolkits", "toolkit status", "setup my toolkit", "sync my setup", or asks about toolkit management and cross-machine synchronization.
Use when user asks to "explain", "walk through", "break down", "help me understand", or needs to understand something complex progressively. Works for any domain — PR changes, code, documents, concepts, processes, architectures. Also triggers on "explain this PR", "walk me through", "break down these changes", "step by step", "what does this do". For "break down" into actionable work items with dependencies, use decompose-problem instead.
Uses power tools
Uses Bash, Write, or Edit tools
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
What you learn in one session dies when the session ends. Debug the same issue twice? Rediscover the same pattern? That knowledge vanishes.
claude-evolve creates a personal toolkit plugin that captures what you learn and turns it into reusable components — agents, skills, rules — that load automatically in future sessions.
Your toolkit starts empty and grows as you work. Works with any domain: coding, writing, research, design, ops.
1. You debug something
> "Oh, the auth issue was caused by stale tokens"
2. Claude flags it (or you do manually)
/evolve signal "stale token pattern causes auth failures"
3. Extract the learning
/learn
→ Creates a rule: "Check token freshness before auth debugging"
4. Next session
→ Knowledge loads automatically
→ You skip the same debugging trap
# Install
/plugin marketplace add hknc/claude-evolve
/plugin install claude-evolve@claude-evolve
# Better /learn components (recommended)
/plugin marketplace add anthropics/claude-plugins-official
/plugin install plugin-dev@claude-plugins-official
# Restart Claude Code, then initialize your toolkit
/evolve init # Creates ~/.claude-evolve/toolkits/my-toolkit/
claude-evolve ships meta-agents — agents that create your personalized agents, skills, and rules based on your actual work and preferences. These components evolve over time as you use them.
| Included | Purpose |
|---|---|
| 9 agents | Learning extraction, reflection, decisions, risk, progress |
| 13 skills | Problem decomposition, root cause, comparison, research |
| Workflow guides | Depth-aware phases that scale with complexity |
See docs/reference.md for full component details.
/evolve init creates a local plugin at ~/.claude-evolve/ that you own. As you work, /learn adds components to it:
| Component | Example | Created From |
|---|---|---|
| Rule | "Always check X before Y" | Past corrections |
| Skill | "Debug auth issues" | Repeated patterns |
| Agent | "Investigate perf issues" | Investigation approaches |
Components accumulate in your toolkit over time. Each /learn adds to what you've built — shaped by your work, not generic templates.
| Command | Purpose |
|---|---|
/evolve signal | Flag insight for capture |
/learn | Extract signals → agents/skills/rules |
/reflect | Synthesize observations → understanding.md |
/reflect creates understanding.md — a condensed file of your patterns that loads at session start. Claude remembers how you work.
Say "let's build" to start a guided flow:
SPEC.md)Task complexity is assessed automatically:
| Depth | When | Phases |
|---|---|---|
execute | Simple task | No phases — just do it |
check | Low complexity | verify |
plan | Medium complexity | action → outcome |
design | High complexity | requirements → design → implement → testing |
explore | Unclear + high stakes | research → prototype → evaluate → decide |
| Command | Purpose |
|---|---|
/workflow | Show current phase |
/workflow next | Advance phase |
/workflow done | Complete workflow |
Your toolkit is a local plugin that persists across sessions:
| Command | Purpose |
|---|---|
/evolve init | Create your toolkit plugin |
/evolve status | Show version and changes |
/evolve release | Push to remote |
/evolve audit | Audit and optimize config |
/evolve prepare | Check toolkit gaps before complex tasks |
/evolve context | Analyze current project, suggest relevant agents |
Machine A Machine B
───────── ─────────
Work → /learn → toolkit grows
│
▼
/evolve release ────► Git ────► Claude Code auto-updates
│
▼
Your toolkit available here too
MIT
npx claudepluginhub hknc/claude-evolveMulti-model consensus engine integrating OpenAI Codex CLI, Gemini CLI, and Claude CLI for collaborative code review and problem-solving.
Ultra-compressed communication mode. Cuts ~75% of tokens while keeping full technical accuracy by speaking like a caveman.
Comprehensive UI/UX design plugin for mobile (iOS, Android, React Native) and web applications with design systems, accessibility, and modern patterns
Curate auto-memory, promote learnings to CLAUDE.md and rules, extract proven patterns into reusable skills.
Memory compression system for Claude Code - persist context across sessions
Standalone image generation plugin using Nano Banana MCP server. Generates and edits images, icons, diagrams, patterns, and visual assets via Gemini image models. No Gemini CLI dependency required.