# Subagent Creator

> Create, validate, and refine Claude Code subagents for reliable delegation. Use when building new subagents, validating existing ones, improving quality, scoping tool access, configuring permission modes, or setting up hook validation. For personal, team, or production environments.

- Skill: `full-stack-biz/subagent-creator` (Agent Skill, multi-file: 11 files)
- Install (CLI): `npx skillmds@latest add full-stack-biz/subagent-creator`
- Raw SKILL.md: https://api.skillmd.com/api/skills/full-stack-biz/subagent-creator/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: full-stack-biz (https://skillmd.com/u/full-stack-biz)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/full-stack-biz/subagent-creator

---


# Subagent Creator

**Dual purpose:** Create subagents right the first time OR elevate existing subagents to best practices.

## Quick Routing

Use AskUserQuestion with **predefined options**:

```
questions: [
  {
    question: "What would you like to do?",
    header: "Action",
    options: [
      {
        label: "Create a new subagent",
        description: "Build a subagent from scratch with proper scope, tool access, and permissions"
      },
      {
        label: "Validate existing subagent",
        description: "Check if subagent is properly configured and production-ready"
      },
      {
        label: "Refine/improve subagent",
        description: "Enhance existing subagent for clarity, efficiency, or reliability"
      }
    ],
    multiSelect: false
  }
]
```

Then route to the appropriate workflow section based on their selection.

---

## When to Use This Skill

- **Creating subagents** — Need structured guidance on scope, model, tool access, permission modes for new subagents
- **Validating subagents** — Ensure correct configuration, delegation clarity, tool scoping, permission modes
- **Improving subagents** — Enhance robustness (tool restrictions, permissions, delegation signals, error handling, hooks)
- **Team/production** — Building for multiple Claude instances; need stability and error handling

### Quick Reference: Three Workflows

| Workflow | Purpose | Steps | Reference |
|----------|---------|-------|-----------|
| **Create** | Build subagent from scratch | 1. Interview → 2. Design → 3. Implement → 4. Validate | `templates.md` + `validation-workflow.md` |
| **Validate** | Check existing subagent | 1. Configuration → 2. Delegation → 3. Prompt → 4. Tools → 5. Permissions → 6. Hooks → 7. Test | `validation-workflow.md` + `checklist.md` |
| **Refine** | Improve existing subagent | 1. Identify issues → 2. Target improvements → 3. Update → 4. Re-validate | `checklist.md` + topic-specific refs |

## Why This Exists

**Mindset:** Subagents are execution FOR CLAUDE, not documentation FOR PEOPLE. Question: "Will Claude reliably delegate & execute?" not "Does this read well?"

Subagents isolate task execution with custom prompts, tool access, permissions. Without structured guidance, they become misconfigured and unreliable. This skill ensures every subagent is optimized for reliable delegation and execution from creation.

## Foundation: Subagent Architecture

Subagents are isolated execution environments with independent configuration (prompt, tools, permissions). Claude delegates to subagents based on request context using natural language matching against descriptions. For complete architectural details including delegation mechanisms, configuration options, and integration patterns, see `references/how-subagents-work.md`.

## Implementation Approach

**⚠️ CRITICAL: Scope Detection & Clarification**

Always detect project type first, then clarify scope only when needed:

**Allowed scopes (project-scoped only):**
- **Claude plugin projects** (has `.claude-plugin/plugin.json`): Subagents in `agents/` (plugin) or `.claude/agents/` (project-level)
- **Regular projects**: Subagents in `.claude/agents/` only

**🚫 Forbidden scopes (REFUSE all editing attempts):**
- `~/.claude/plugins/cache/` — Installed/cached plugins
- `~/.claude/agents/` — User-space subagents (affects all projects)
- Global installations or outside project root

**If user provides forbidden path:** Refuse with explanation: "Subagent-creator only works with project-scoped subagents. User-space subagents (`~/.claude/agents/`) affect all projects and should not be edited here."

**START HERE - Scope Detection & Clarification Flow:**

1. **Ask Question 1: Action type**
   - Create a new subagent (Recommended)
   - Validate an existing subagent
   - Refine a subagent

2. **AUTO-DETECT: Check for `.claude-plugin/plugin.json`**
   - If it exists (project is a Claude plugin): Go to step 3a
   - If it doesn't exist (regular project): Go to step 3b

3a. **IF PROJECT IS A CLAUDE PLUGIN - Ask Question 2: Scope choice with predefined options**

```
questions: [
  {
    question: "Should this subagent be part of the plugin or project-level?",
    header: "Scope",
    options: [
      {
        label: "Part of the plugin",
        description: "Add to agents/ directory (bundled with plugin for distribution)"
      },
      {
        label: "Project-level",
        description: "Add to .claude/agents/ directory (local, not bundled with plugin)"
      }
    ],
    multiSelect: false
  }
]
```

Then ask: "What do you want to call it?" (e.g., `db-analyzer`, `code-reviewer`, `compliance-auditor`)

3b. **IF PROJECT IS REGULAR - No scope question needed**
   - Inform user: "Creating project-level subagent in `.claude/agents/`"
   - Ask: "What do you want to call it?" (e.g., `db-analyzer`, `code-reviewer`, `compliance-auditor`)

**For validating/refining:** Ask "Provide the subagent name or path relative to project root" (e.g., `agents/db-analyzer` for plugins or `.claude/agents/db-analyzer` for regular projects)

Based on answers, route to the appropriate workflow below.

### For New Subagents: Requirements Interview First

After routing to "create", **interview the user to gather requirements** using AskUserQuestion with proper options:

```
questions: [
  {
    question: "What specialized task should this subagent execute? What problem does isolation solve?",
    header: "Purpose & Scope",
    options: [] // Open-form
  },
  {
    question: "When should Claude delegate to this subagent? What request phrases trigger it?",
    header: "Delegation Trigger",
    options: [] // Open-form
  },
  {
    question: "Which tools will this subagent need? (Apply principle of least privilege)",
    header: "Tool Access",
    options: [] // Open-form
  },
  {
    question: "How should the subagent handle permission prompts?",
    header: "Permission Mode",
    options: [
      { label: "default", description: "Prompt for each permission (standard behavior)" },
      { label: "acceptEdits", description: "Auto-accept file edits without prompting" },
      { label: "dontAsk", description: "Auto-accept all permissions without prompting" },
      { label: "plan", description: "Use plan mode for structured permission flow" }
    ],
    multiSelect: false
  }
]
```
5. **Model choice** - Should it use fast Haiku, standard Sonnet, or powerful Opus? Or inherit from parent?
6. **Hooks & validation** - Does the subagent need conditional tool validation or lifecycle hooks?
7. **Team/production** - Will multiple Claude instances use this? Production data involved?

Then use `references/templates.md` to apply requirements to the appropriate subagent structure.

### For Existing Subagents (Validating)

1. **FIRST: Verify the subagent path is project-scoped** — Check if path contains `.claude/agents/` or `agents/` relative to project root. If path is from `~/.claude/plugins/cache/` or `~/.claude/`, REFUSE and explain project scope
2. **SECOND: Detect if subagent is plugin or project-level** — Infer from path prefix:
   - Path starts with `agents/` → Plugin-level subagent
   - Path starts with `.claude/agents/` → Project-level subagent
3. Follow the systematic workflow in `references/validation-workflow.md` (Phase 1-7)
4. Use `references/checklist.md` to identify gaps during validation
5. Check `references/delegation-signals.md` for description clarity
6. Validate: Complete workflow + checklist before considering the subagent complete

### For Improvements (Refining)

1. **FIRST: Verify the subagent path is project-scoped** — Check if path is in project directory, NOT in installed locations. Refuse if it's installed/cached
2. **SECOND: Detect scope from path** — Determine if subagent is plugin-level or project-level based on path prefix
3. Ask user which aspects need improvement (delegation, tools, permissions, etc.)
4. Reference relevant sections from `references/checklist.md` or `references/delegation-signals.md`
5. Make targeted improvements rather than rewriting everything

## Outcome Metrics

Measure success by whether Claude will reliably delegate to and execute the subagent:

✅ **Description clarity** - Includes specific trigger phrases Claude will recognize; delegates reliably when needed
✅ **Configuration** - Correct YAML frontmatter (name, description, tools, permissionMode, model, hooks)
✅ **Prompt quality** - System prompt is clear, procedural, and context-appropriate
✅ **Tool scoping** - Only necessary tools declared; principle of least privilege enforced
✅ **Permission mode** - Appropriate for use case (foreground vs background, interactive vs auto-deny)
✅ **Hooks** - Correctly configured for validation/lifecycle when needed
✅ **Integration** - Tested with real delegation scenarios; works with both foreground and background execution

## Quick Start: Creating a New Subagent

When helping the user create a subagent, follow these steps:

**Step 1: Prepare storage location**
Guide the user to create the directory:
- Global: `~/.claude/agents/`
- Project-local: `.claude/agents/`

**Step 2: Create the Markdown file**
Write the subagent configuration with YAML frontmatter + system prompt body. Example structure:

```yaml
---
name: db-analyzer
description: >-
  Execute read-only database queries to analyze data. Use when exploring
  databases, generating reports, or analyzing data patterns. Supports
  SELECT queries only; write operations blocked.
model: sonnet
tools: Bash, Read, Write
permissionMode: dontAsk
---

You are a database analyst with read-only access...
```

**Step 3: Apply guidelines for Claude's delegation**
Ensure the subagent meets these requirements:
- **name**: lowercase-hyphen, ≤64 chars, unique within scope
- **description**: ≤1024 chars, must include specific trigger phrases (this is Claude's delegation signal)
- **tools**: Allowlist or omit to inherit all tools
- **model**: sonnet (default), opus, haiku, or inherit from parent
- **permissionMode**: default (ask), acceptEdits (auto-accept edits), dontAsk (auto-deny), bypassPermissions (skip checks), plan (read-only)

**Step 4: Write the system prompt**
The prompt body is what Claude executes when delegated. Structure: Purpose → Key behaviors → Constraints → Examples

**Step 5: Add hooks if needed**
For conditional tool validation (e.g., read-only database access), guide the user to configure PreToolUse hooks with validation scripts.

**Step 6: Guide user through validation**
Have the user review the checklist in `references/checklist.md` before deployment. Then guide them through real-world testing: try requests that should trigger delegation, and requests that should not.

## Refining Existing Subagents

1. **Follow the validation workflow** (`references/validation-workflow.md`) to identify issues systematically
2. **Review against the checklist** (`references/checklist.md`) during validation
3. **Improve so Claude delegates and executes reliably:** description clarity (delegation) → configuration correctness → prompt clarity → hooks/validation if needed
4. **Guide user to test delegation:** Ask them to make requests using the trigger phrases from the description. Check: Does Claude delegate to this subagent? If not, the description needs clearer trigger language.
5. **Guide user to test execution:** Once delegation works, verify the subagent can complete the task with its prompt and tools. Ask the user to test actual workflows.
6. **Re-validate** using the workflow before considering refinements complete

## Reference Guide

### Creating a New Subagent

**Step 1: Understand subagent architecture**
→ How Claude delegates, execution models, when to use subagents, delegation mechanisms
→ `references/how-subagents-work.md` for architecture overview

**Step 2: Choose starting template**
→ Real-world examples and copy-paste starting points for common patterns
→ `references/templates.md`

**Step 3: Write clear delegation signals**
→ Descriptions trigger Claude's delegation. Include specific trigger phrases; vague descriptions = poor reliability.
→ `references/delegation-signals.md` for writing descriptions that trigger delegation

**Step 3b: Write reliable delegation prompts**
→ Pattern: role statement → task → context → explicit outputs → constraints. Based on production implementations (skill-tester, skill-creator).
→ `references/delegation-patterns.md` for proven delegation patterns with real examples

**Step 4: Configure tools & permissions**
→ Grant only necessary tools (principle of least privilege). Permission modes: foreground/interactive, background/concurrent, plan/read-only
→ `references/tool-scoping.md` for tool access patterns
→ `references/permission-modes.md` for permission mode decision matrices

**Step 5: Complete YAML configuration**
→ Frontmatter fields: name, description, model, tools, permissionMode, hooks (PreToolUse, PostToolUse, SubagentStart, SubagentStop)
→ `references/configuration-reference.md` for complete YAML reference

**Step 6: Validate before deployment**
→ 7-phase validation process: configuration → delegation → prompt → tools → permissions → hooks → testing
→ `references/validation-workflow.md` for validation phases
→ `references/checklist.md` for best practices checklist

### Validating Existing Subagents

→ Run 7-phase validation workflow systematically
→ `references/validation-workflow.md` for all phases
→ `references/checklist.md` for quality assessment

### Improving/Refining Subagents

→ Identify gaps using checklist, make targeted improvements, re-validate
→ `references/checklist.md` for identifying issues
→ Topic-specific references as needed

### Production & Advanced Patterns

→ Hook validation, chaining, background execution, lifecycle management, error handling
→ `references/advanced-patterns.md` for production patterns

## Core Principles

1. **Clear Delegation Signals** — Descriptions trigger Claude's delegation. Include specific trigger phrases; vague descriptions = poor reliability.
2. **Principle of Least Privilege** — Grant only necessary tools. Use allowlist scoping and hooks for conditional validation (e.g., read-only queries).
3. **Appropriate Permission Mode** — Match mode to use case: foreground/interactive, background/concurrent, or plan/read-only.
4. **Configuration Clarity** — Validate YAML syntax, tool names, model values, and required fields before deploying.

## Key Notes

**Frontmatter essentials:**
- `name`: Required, lowercase-hyphen, ≤64 chars (Claude's reference label)
- `description`: Required, ≤1024 chars, must include trigger phrases Claude recognizes (PRIMARY delegation signal)
- Example formula: `[Action]. Use when [trigger contexts]. [Scope/constraints].`

**Common optional fields:**
- `model`: sonnet|opus|haiku|inherit (default: sonnet)
- `tools`: Allowlist tools (default: inherit all)
- `permissionMode`: default|acceptEdits|dontAsk|bypassPermissions|plan
- `hooks`: PreToolUse, PostToolUse, SubagentStart, SubagentStop for validation/lifecycle

**Scope storage (project-scoped only; subagent-creator refuses user-space):**
- ✅ Project-local: `.claude/agents/` (recommended)
- ✅ Plugin: `agents/` in plugin directory (for plugin projects)
- 🚫 Global/User-space: `~/.claude/agents/` (forbidden; affects all projects — do not edit here)

For complete configuration reference, defaults, field combinations, naming conventions, and permission mode decision matrices, see `references/configuration-reference.md` and `references/permission-modes.md`.

**Team/Production:**
- Error handling: prompts must handle failures gracefully
- Tool scoping: principle of least privilege (see `tool-scoping.md`)
- Hooks: validation scripts must be tested before deployment
- See `checklist.md` → "Team & Production Subagents" for full considerations and `advanced-patterns.md` for production patterns