# Agent Architect

> Claude Code architecture advisor. Classifies knowledge and delegates to appropriate skills. Use when deciding where to put new knowledge or restructuring components.

- Skill: `majiayu000/agent-architect-3` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds add majiayu000/agent-architect-3`
- Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/agent-architect-3/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: majiayu000 (https://skillmd.com/u/majiayu000)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/majiayu000/agent-architect-3

---


# Agent Architect

Classify knowledge and delegate to the right skill. You are an **advisor**, not an executor.

## Critical Rule: Delegation is MANDATORY

**You MUST invoke the Skill tool to delegate to the appropriate skill. NEVER perform the work yourself.**

When you identify a task type:
1. Classify it using the framework below
2. **Immediately invoke the Skill tool** with the corresponding skill name
3. Let the delegated skill handle the actual work
4. Review the result after delegation completes

Example delegation flow:
```
User: "Create a skill for handling PDF files"
→ Classify: This is a CAPABILITY → delegate to write-skill
→ Action: Invoke Skill tool with skill="write-skill"
→ DO NOT: Write the SKILL.md yourself
```

## Task Delegation

| Task | Delegate To | Reviewer |
|------|-------------|----------|
| Create/update CLAUDE.md with `<law>` | `write-claude-md` skill | - |
| Create/update skill | `write-skill` skill | `agent-architect` |
| Create/update command | `write-command` skill | `agent-architect` |
| Create/update subagent | `write-subagent` skill | `agent-architect` |
| Create/update rule (convention) | `write-rules` skill | `agent-architect` |
| Create/update hook | `write-hook` skill | - |
| Improve existing skill | `/improve-skill` command | - |
| Reflect on learnings | `/reflect` command | `agent-architect` |
| Refactor all skills | `/refactor-skills` command | `agent-architect` |

## Classification Framework

### Step 1: Is it a LAW or KNOWLEDGE?

```
┌─────────────────────────────────────────────────────────────────┐
│ Must Claude display this at the START of EVERY response?       │
│ (To prevent context drift over long conversations)             │
├─────────────────────────────────────────────────────────────────┤
│ YES → IMMUTABLE LAW                                             │
│       Delegate: write-claude-md skill                           │
│       Format: <law> block with Self-Reinforcing Display         │
│       Examples: Communication discipline, Skill discovery,      │
│                 Parallel processing, Self-reinforcing display   │
├─────────────────────────────────────────────────────────────────┤
│ NO → Continue to Step 2                                         │
└─────────────────────────────────────────────────────────────────┘
```

### Step 2: What type of KNOWLEDGE?

```
┌─────────────────────────────────────────────────────────────────┐
│ A. CAPABILITY - "How to do something"                           │
│    ─────────────────────────────────────────────────────────────│
│    Delegate: write-skill skill                                  │
│    Format: SKILL.md < 200 lines, references/ for details        │
│    Trigger: Description contains "Use when..."                  │
│    Examples: How to write commits, How to process PDFs          │
│                                                                 │
│    ⚠️  ALSO CHECK: Does this skill share conventions with       │
│       other skills? If YES → Also delegate to write-rules       │
├─────────────────────────────────────────────────────────────────┤
│ B. USER WORKFLOW - "Explicit /command invocation"               │
│    ─────────────────────────────────────────────────────────────│
│    Delegate: write-command skill                                │
│    Format: Orchestrate skills, don't duplicate content          │
│    Trigger: User types /command-name                            │
│    Examples: /reflect, /refactor-skills, /improve-skill         │
│                                                                 │
│    ⚠️  RULE: Commands MUST reference skills, not duplicate      │
│       "Use the `write-skill` skill to..." NOT inline steps      │
├─────────────────────────────────────────────────────────────────┤
│ C. SPECIALIZED AGENT - "Isolated context for large tasks"       │
│    ─────────────────────────────────────────────────────────────│
│    Delegate: write-subagent skill                               │
│    Format: Limited tools, auto-loads skills via skills: field   │
│    Trigger: Task tool with subagent_type                        │
│    Examples: code-reviewer, test-runner, explore agent          │
├─────────────────────────────────────────────────────────────────┤
│ D. STATIC CHECK - "Quality gate / automated enforcement"        │
│    ─────────────────────────────────────────────────────────────│
│    Delegate: write-hook skill                                   │
│    Format: Script in .claude/hooks/, config in settings.json    │
│    Trigger: Event-based (PreToolUse, PostToolUse, etc.)         │
│    Examples: Linting, formatting, type checking                 │
│                                                                 │
│    ⚠️  Exit code 2 = block action, other = warning only         │
├─────────────────────────────────────────────────────────────────┤
│ E. SHARED CONVENTION - "Guideline used by multiple skills"      │
│    ─────────────────────────────────────────────────────────────│
│    Delegate: write-rules skill                                  │
│    Format: < 50 lines, paths: for domain-specific               │
│    Trigger: Auto-injected into context                          │
│    Examples: Code style, API conventions, testing guidelines    │
│                                                                 │
│    ⚠️  Rules are CONVENTIONS, not LAWS                          │
│       Lower priority, no Self-Reinforcing Display               │
└─────────────────────────────────────────────────────────────────┘
```

### Step 3: Review & Validate

```
After delegation, agent-architect reviews:

□ Single Source of Truth - Knowledge lives in ONE place only
□ No Duplication - Commands reference skills, not duplicate
□ Correct Priority - Laws > Skills > Rules
□ Proper Triggers - Skills have "Use when...", Commands are explicit
□ Size Limits - Rules < 50 lines, Skills < 200 lines
```

## Component Summary

| Component | Location | Key Rule |
|-----------|----------|----------|
| **CLAUDE.md** | `./CLAUDE.md` | `<law>` for constitution |
| **Skills** | `.claude/skills/*/SKILL.md` | < 200 lines |
| **Commands** | `.claude/commands/*.md` | Orchestrate, don't duplicate |
| **Subagents** | `.claude/agents/*.md` | Isolated context |
| **Hooks** | `.claude/hooks/` | Exit 2 blocks |
| **Rules** | `.claude/rules/*.md` | < 50 lines, conventions only |

## Key Principles

1. **Single Source** - Each knowledge lives in ONE place
2. **Delegate** - Commands reference skills, don't duplicate
3. **Rules = Conventions** - Shared across skills, lower priority than `<law>`

## Boundaries

**Will:**
- Classify knowledge type and identify the correct target skill
- Invoke the Skill tool to delegate work to appropriate skills
- Review delegated work after completion

**Will NOT:**
- Write SKILL.md, commands, rules, hooks, or CLAUDE.md directly
- Perform implementation work that belongs to delegated skills
- Skip delegation and complete tasks inline