Forge Analyzer

Understands what users actually need, not what category their project fits into.

Philosophy

"What problem are you solving?" - not "Is this a skill or an agent?"

Architecture emerges from understanding, not from matching patterns to templates.

When to Use

Invoke this skill when:

• User has a vague or ambiguous request
• Wizard cannot determine the right route from pattern matching
• User says things like "I want to make something that..." or "I'm not sure what I need"
• Need to clarify requirements before creating skill/agent/command

Analysis Dimensions

Instead of categories, analyze along these dimensions:

1. State Complexity

2. Interaction Boundary

3. Context Requirements

4. Execution Pattern

5. Integration Surface

Analysis Process

Step 1: Gather Requirements

Ask open-ended questions:

AskUserQuestion:
  question: "What problem does this solve for you?"
  header: "Problem"
  options:
    - label: "Automate repetitive task"
      description: "Something I do often that could be automatic"
    - label: "Enforce a rule"
      description: "Prevent mistakes or ensure quality"
    - label: "Provide information"
      description: "Answer questions or give guidance"
    - label: "Connect systems"
      description: "Bridge between different tools/services"

Step 2: Map Dimensions

State:        [stateless] -------- [session] -------- [persistent]
Interaction:  [reactive] --------- [interactive] ---- [proactive]
Context:      [minimal] ---------- [moderate] ------- [extensive]
Execution:    [sync] ------------- [mixed] ---------- [async]
Integration:  [internal] --------- [hybrid] --------- [external]

Step 3: Derive Architecture & Route to Wizard

Output Format

After analysis, recommend and route. Connection Plan is MANDATORY:

## Forge Analysis Result

### Problem Understanding
{Summary of what the user needs}

### Dimension Analysis
- State: {spectrum position} - {reason}
- Interaction: {spectrum position} - {reason}
- Context: {spectrum position} - {reason}
- Execution: {spectrum position} - {reason}
- Integration: {spectrum position} - {reason}

### Recommended Architecture
{Specific recommendation}

### Connection Plan (REQUIRED)
| Registration | Location | Status |
|--------------|----------|--------|
| {type} | {file path} | [ ] Pending |

Entry points:
- {How users/system will access this component}

### Next Step
1. Wire connections (registrations above)
2. Create component via: {Wizard route or agent}
3. Verify with validate_all.py

Integration with Wizard

After forge analysis completes:

Task(subagent_type: "skill-architect")

Task(subagent_type: "skill-orchestrator-designer")

Task(subagent_type: "architecture-smith")

Connectivity-First Design

CRITICAL: Every component must be connected at creation time, not validated later.

When creating ANY component, verify connectivity BEFORE implementation:

Connection Checklist

Pre-Creation Questions

Before creating any component:

AskUserQuestion:
  question: "How will this component be accessed?"
  header: "Connectivity"
  options:
    - label: "Via wizard route"
      description: "Route pattern in wizard SKILL.md"
    - label: "Via command"
      description: "User runs /plugin:command"
    - label: "Via agent spawning"
      description: "Task(subagent_type: 'name')"
    - label: "Automatically via hooks"
      description: "Triggered by tool use patterns"

Connection Blueprint

When recommending architecture, ALWAYS include connection plan:

## Connection Plan

### 1. Entry Points
- Wizard route: `{pattern}` → ROUTE_NAME
- Command: `/plugin:{name}`
- Agent spawn: `Task(subagent_type: "{name}")`

### 2. Required Registrations
- [ ] plugin.json → agents[] or commands[]
- [ ] marketplace.json → agents[] or commands[]
- [ ] wizard SKILL.md → routing table (if applicable)
- [ ] hooks.json → matchers (if hook script)

### 3. Internal References
- Parent skill/agent → references/
- Skill loading: Skill("plugin:{name}")

Creation Workflow

1. Determine component type from dimension analysis
2. Generate connection blueprint
3. Present blueprint to user for confirmation
4. Create component WITH connections (not after)
5. Run validate_all.py to confirm connectivity

Why Connectivity-First?

Anti-Patterns