By chkim-su
Design guidance + execution system for Claude Code plugin development with 9-phase operational workflow
Design option synthesis (Phase 5)
Codebase reality description (Phase 2)
Main entry - 0-stage semantic routing for plugin design
Smart routing wizard for plugin development tasks
Workflow management (Phase 6-7-8)
Use this agent to analyze existing plugin code and describe reality. Examples: <example> Context: Need to understand existing plugin structure user: "Analyze this plugin's current state" assistant: "I'll use the codebase-analyzer to describe what the code actually does" <commentary> Describes factual behavior, not claims from comments or docs </commentary> </example> <example> Context: Before modifying existing plugin user: "What does this hook actually do?" assistant: "Let me analyze the codebase to describe the actual behavior" <commentary> Phase 2 describes reality before any modifications </commentary> </example>
Use this agent to execute confirmed designs after user approval. Examples: <example> Context: User confirmed the workflow user: "Yes, proceed with implementation" assistant: "I'll use the execution-orchestrator to implement the confirmed design" <commentary> STRICT phase - requires explicit user confirmation before any execution </commentary> </example> <example> Context: Ready to create plugin files user: "Go ahead and create the files" assistant: "Executing the confirmed design with scaffolding and implementation" <commentary> Creates files, refactors code, applies hooks/daemon/MCP as designed </commentary> </example>
Use this agent when starting a new plugin design task to normalize user intent. Examples: <example> Context: User wants to create a new plugin feature user: "I want to add validation to my plugin" assistant: "I'll use the input-normalizer agent to understand your requirements" <commentary> Triggers because user intent needs normalization before design can proceed </commentary> </example> <example> Context: Ambiguous plugin request user: "Help me with hooks" assistant: "Let me normalize this request to understand what you need" <commentary> Vague requests need Phase 0 normalization to extract clear problem statement </commentary> </example>
Use this agent to compare user intent against codebase reality. Examples: <example> Context: After analyzing existing plugin code user: "Does this match what I want to build?" assistant: "I'll use the mismatch-evaluator to compare intent vs reality" <commentary> Compares Phase 0 intent with Phase 2 observations to find gaps </commentary> </example> <example> Context: User assumes feature exists but it doesn't user: "I thought there was already a validation hook" assistant: "Let me evaluate the mismatch between your expectation and reality" <commentary> Significant mismatches trigger Phase 4 questioning </commentary> </example>
Use this agent to synthesize design options with trade-offs. Examples: <example> Context: Decision variables collected, ready for design user: "What are my options for implementing this?" assistant: "I'll use the option-synthesizer to propose design alternatives" <commentary> Proposes options with structural placement and trade-offs, not answers </commentary> </example> <example> Context: Multiple valid approaches exist user: "Should I use a hook or an agent?" assistant: "Let me synthesize options with pros and cons for each approach" <commentary> Presents options with schema-informed placement and honest trade-offs </commentary> </example>
Phase transition rules and completion criteria for Forge 9-phase workflow
Complete schema reference for Claude Code plugin development - plugin.json, marketplace.json, frontmatter, and hooks.json. This skill should be used when designing plugins, validating schemas, or understanding component structure.
Structured Dialogue Contract format reference for Forge Phase 4 questioning
Smart routing wizard for plugin development tasks. Routes to appropriate Forge agents via explicit Task(subagent_type="forge:*") pattern. This skill should be used when the /forge command is invoked or when routing decisions need to be made for plugin design, analysis, or validation.
Executes bash commands
Hook triggers when Bash tool is used
Modifies files
Hook triggers on file write and edit operations
Uses power 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.
Uses Bash, Write, or Edit tools
Uses Bash, Write, or Edit tools
Design guidance + execution system for Claude Code plugin development.
Forge helps you structure decisions about how to design or improve plugins, skills, agents, commands, hooks, and MCP components in a semantically correct way.
Forge is a design guidance + execution system that:
Forge is NOT:
# Start the full workflow
/forge I want to add a validation hook
# Direct phase access
/forge analyze scripts/ # Codebase analysis
/forge design # Design options
/forge validate # Validation check
# Show interactive menu
/forge
| Phase | Name | Strict | Description |
|---|---|---|---|
| 0 | Input Normalization | YES | Normalize intent, identify scope |
| 1 | Semantic Routing | no | 0-stage triage based on hints |
| 2 | Codebase Reality | no | Factual description of code |
| 3 | Mismatch Evaluation | no | Compare intent vs reality |
| 4 | Structured Questioning | YES | Collect decision variables |
| 5 | Option Synthesis | no | Propose options with trade-offs |
| 6 | Workflow Creation | no | Create workflow if needed |
| 7 | Execution | YES | Execute after confirmation |
| 8 | Validation | no | Final validation gate |
Phases 0, 4, and 7 are strict - they enforce tool restrictions:
| Command | Description |
|---|---|
/forge | Main entry with routing |
/diagnose | Direct Phase 2 (codebase analysis) |
/design | Direct Phase 5 (options) |
/workflow | Workflow management |
| Agent | Phase | Purpose |
|---|---|---|
| input-normalizer | 0 | Normalize intent |
| semantic-router | 1 | Triage routing |
| codebase-analyzer | 2 | Reality description |
| mismatch-evaluator | 3 | Intent vs reality |
| questioner | 4 | Structured questioning |
| option-synthesizer | 5 | Design options |
| workflow-manager | 6 | Workflow creation |
| execution-orchestrator | 7 | Confirmed execution |
| validator | 8 | Final validation |
Phase 4 questions must follow this format:
Problem:
<mismatch or ambiguity>
Codebase:
<current design intent>
Evidence:
<specific observations>
Question:
<decision variable, NOT choice>
Question Intent:
<why this matters>
See references/structured-dialogue-contract.md for details.
Workflows support dynamic versioning:
If workflow is modified after confirmation, reconfirmation is required.
Forge uses a daemon for state management:
# Check state
python3 scripts/forge-state.py state
# Check phase
python3 scripts/forge-state.py phase
# Check workflow
python3 scripts/forge-state.py workflow
Forge uses hooks for enforcement:
| Hook | Purpose |
|---|---|
| SessionStart | Initialize state |
| UserPromptSubmit | Detect confirmation |
| PreToolUse | Phase-appropriate tools |
| PostToolUse | Phase completion |
| Stop | Validation check |
This implementation follows the Forge specification in plan.txt. The user will dogfood by running Forge on itself after completion.
forge/
├── plugin.json # Plugin manifest
├── commands/ # 4 commands
├── skills/ # 2 reference skills
├── agents/ # 9 phase agents
├── hooks/forge.json # Hook configuration
├── scripts/ # Daemon and hook scripts
├── config/ # Phase definitions
└── references/ # Documentation
MIT
npx claudepluginhub chkim-su/forge --plugin forgeComplete plugin development toolkit for creating, refactoring, and validating Claude Code plugins and agents. Use when creating new plugins/skills/agents, refactoring existing plugins/skills, validating frontmatter, or restructuring plugin components. Includes specialized agents for assessment, planning, execution, and validation workflows.
Create and manage Claude Code skills, plugins, subagents, and hooks. Use when building new skills, validating existing skills, testing skills empirically, creating plugins, converting projects to plugins, creating hooks, or managing plugin automation. Includes /skills-toolkit:skill-composer, /skills-toolkit:skill-refiner, /skills-toolkit:skill-tester, /skills-toolkit:plugin-creator, /skills-toolkit:subagent-creator, /skills-toolkit:hook-creator, and /skills-toolkit:ask-user-question skills.
Harness-native ECC operator layer - 67 agents, 271 skills, 92 legacy command shims, reusable hooks, rules, selective install profiles, and production-ready workflows for Claude Code, Codex, OpenCode, Cursor, and related agent harnesses
Feature development with code-architect/explorer/reviewer agents, CLAUDE.md audit and session learnings, and Agent Skills creation with eval benchmarking from Anthropic.
Comprehensive feature development workflow with specialized agents for codebase exploration, architecture design, and quality review
Access thousands of AI prompts and skills directly in your AI coding assistant. Search prompts, discover skills, save your own, and improve prompts with AI.