Agent Expert Creation

Agent Expert Creation Skill

Create specialized agent experts that learn and maintain domain knowledge through the Act-Learn-Reuse pattern.

Core Problem Solved

"The massive problem with agents is this. Your agents forget. And that means your agents don't learn."

Generic agents execute and forget. Agent experts execute and learn by maintaining expertise files (mental models) that sync with the codebase.

When to Use

• Repeated complex tasks in a domain (database, billing, WebSocket)
• High-risk systems where mistakes cascade (security, payments)
• Rapidly evolving code that needs tracked mental models
• Need consistent domain expertise across sessions
• Building plan-build-improve automation cycles

The Act-Learn-Reuse Pattern

┌─────────────────────────────────────────────────────────────┐
│                    ACT-LEARN-REUSE CYCLE                    │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   ACT ──────────► LEARN ──────────► REUSE                   │
│    │                │                  │                    │
│    │                │                  │                    │
│    ▼                ▼                  ▼                    │
│  Take useful    Update expertise    Read expertise          │
│  action         file via            file FIRST on           │
│  (build, fix)   self-improve        next execution          │
│                 prompt                                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Expertise Files (Mental Models)

"The expertise file is the mental model of the problem space for your agent expert... This is not a source of truth. This is a working memory file, a mental model."

Critical Distinction

Expertise File Structure (YAML)

overview:
  description: "High-level system description"
  tech_stack: "Key technologies"
  patterns: "Architectural patterns"

core_implementation:
  module_name:
    file: "path/to/file.py"
    lines: 400
    purpose: "What this module does"

schema_structure:  # For database experts
  tables:
    table_name:
      purpose: "What this table stores"
      key_columns: ["id", "created_at"]

key_operations:
  operation_category:
    operation_name:
      function: "function_name()"
      logic: "How it works"

best_practices:
  - "Practice 1"
  - "Practice 2"

known_issues:
  - "Issue 1 with workaround"

Line Limits (Critical)

Why limits matter: Context window protection. Expertise files must remain scannable.

Expert Creation Process

Step 1: Define the Domain

Identify expertise areas based on risk and complexity:

Step 2: Design Expert Directory Structure

.claude/commands/experts/{domain}/
  expertise.yaml        # Mental model (~600-1000 lines max)
  question.md           # REUSE: Query expertise without coding
  self-improve.md       # LEARN: Sync mental model with codebase
  plan.md               # REUSE: Create plan using expertise
  plan-build-improve.md # Full ACT→LEARN→REUSE workflow

Step 3: Create the Self-Improve Prompt

"Don't directly update this expertise file. Teach your agents how to directly update it so they can maintain it."

The self-improve prompt teaches agents HOW to learn:

# {Domain} Expert - Self-Improve

Maintain expertise accuracy by comparing against actual codebase implementation.

## Workflow

1. **Check Git Diff** (if $1 is true)
   - Run `git diff HEAD~1` to see recent changes
   - Skip if no changes relevant to {domain}

2. **Read Current Expertise**
   - Load expertise.yaml mental model

3. **Validate Against Codebase**
   - Line-by-line verification against source files
   - Check file paths, line counts, function names

4. **Identify Discrepancies**
   - List what changed vs what expertise says
   - Prioritize significant changes

5. **Update Expertise File**
   - Sync mental model with actual code
   - Add new patterns discovered
   - Remove outdated information

6. **Enforce Line Limit (MAX_LINES: 1000)**
   - Condense if exceeding limit
   - Prioritize critical information

7. **Validation Check**
   - Ensure valid YAML syntax
   - Verify all file references exist

Step 4: Create Expert Commands

The plan-build-improve triplet:

Expert Definition Template

Sub-Agent Expert

---
name: {domain}-expert
description: Expert in {domain} for {purpose}
tools: [focused tool list]
model: sonnet
color: blue
---

# {Domain} Expert

You are a {domain} expert specializing in {specific area}.

## Expertise

- Deep knowledge of {domain concepts}
- Experience with {common patterns}
- Understanding of {best practices}

## Workflow

1. Analyze the request
2. Apply domain expertise
3. Provide structured output

## Output Format

{Structured format for this expert's outputs}

Plan Command

---
description: Plan {domain} implementation with detailed specifications
argument-hint: <{domain}-request>
model: opus
allowed-tools: Read, Glob, Grep, WebFetch
---

# {Domain} Expert - Plan

You are a {domain} expert specializing in planning {domain} implementations.

## Expertise

[Pre-loaded domain knowledge here]

## Workflow

1. **Establish Expertise**
   - Read relevant documentation
   - Review existing implementations

2. **Analyze Request**
   - Understand requirements
   - Identify constraints

3. **Design Solution**
   - Architecture decisions
   - Implementation approach
   - Edge cases

4. **Create Specification**
   - Save to `specs/experts/{domain}/{name}-spec.md`

Build Command

---
description: Build {domain} implementation from specification
argument-hint: <spec-file-path>
model: sonnet
allowed-tools: Read, Write, Edit, Bash
---

# {Domain} Expert - Build

You are a {domain} expert specializing in implementing {domain} solutions.

## Workflow

1. Read the specification completely
2. Implement according to spec
3. Validate against requirements
4. Report changes made

Improve Command

---
description: Improve {domain} expert knowledge based on completed work
argument-hint: <work-summary>
model: sonnet
allowed-tools: Read, Write, Edit
---

# {Domain} Expert - Improve

Update expert knowledge based on work completed.

## Workflow

1. Analyze completed work
2. Identify new patterns learned
3. Update expert documentation
4. Capture lessons learned

Example: Hook Expert

Sub-Agent: hook-expert

---
name: hook-expert
description: Expert in Claude Code hooks for automation
tools: [Read, Write, Edit, Bash]
model: sonnet
color: cyan
---

# Claude Code Hook Expert

You are an expert in Claude Code hooks.

## Expertise

- Hook event types (PreToolUse, PostToolUse, UserPromptSubmit, etc.)
- Hook configuration in settings.json
- Python hook implementation patterns
- UV script metadata headers
- Hook input/output contracts

Commands

• /hook_expert_plan - Plan hook implementation
• /hook_expert_build - Build from spec
• /hook_expert_improve - Update hook expertise

Expert File Structure

.claude/
  commands/
    experts/
      {domain}/
        expertise.yaml         # Mental model (600-1000 lines)
        question.md            # Query expertise ($1 = question)
        self-improve.md        # Sync mental model ($1 = check_git_diff)
        plan.md                # Create plan ($1 = task)
        plan-build-improve.md  # Full workflow ($1 = task)

  agents/
    {domain}-expert.md         # Sub-agent definition

specs/
  experts/
    {domain}/
      {feature-name}-spec.md   # Generated specifications

Seeding Strategy

How to Bootstrap an Expert

1. Start Blank - Let agent discover structure

   # expertise.yaml (initial)
   overview:
     description: "To be populated"
   

2. Run Self-Improve - Agent builds initial expertise

   /experts/{domain}/self-improve true
   

3. Iterate - Run self-improve until agent stops finding changes

4. Validate - Ensure accuracy against codebase

When NOT to Build Experts

Anti-Patterns

Expert Patterns

Pattern: Read-Only Expert

For analysis without modification:

Tools: Read, Glob, Grep
Purpose: Audit, review, analyze
Output: Reports and recommendations

Pattern: Build Expert

For implementation work:

Tools: Read, Write, Edit, Bash
Purpose: Create, modify, implement
Output: Code changes and artifacts

Pattern: Research Expert

For information gathering:

Tools: WebFetch, Read, Write
Purpose: Fetch, process, organize
Output: Documentation and summaries

Output Format

When creating an expert, generate:

{
  "expert_name": "{domain}-expert",
  "purpose": "{expertise description}",
  "components": {
    "sub_agent": "{domain}-expert.md",
    "plan_command": "{domain}_expert_plan.md",
    "build_command": "{domain}_expert_build.md",
    "improve_command": "{domain}_expert_improve.md"
  },
  "directories_needed": [
    ".claude/commands/experts/{domain}_expert/",
    "specs/experts/{domain}/",
    "ai_docs/{domain}/"
  ],
  "tools_assigned": ["list", "of", "tools"],
  "model_assignment": {
    "plan": "opus",
    "build": "sonnet",
    "improve": "sonnet"
  }
}

Key Quotes

"The difference between a generic agent and an agent expert is simple. One executes and forgets, the other executes and learns."

"True experts are always learning. They're updating their mental model."

"Build the system that builds the system. Do not work on the application layer."

Cross-References

These are conceptual references to TAC course materials and patterns:

• One Agent, One Purpose - Specialization principle (TAC Lesson 6)
• R&D Framework - Reduce & Delegate strategy (TAC Lesson 8)
• Context Priming Patterns - Loading domain context (TAC Lesson 9)
• 12 Leverage Points - Leverage point #3: System Prompts (TAC Lesson 3)
• TAC Lesson 13: Agent Experts - Act-Learn-Reuse pattern source

Last Updated: 2025-12-15

Version History

• v1.0.0 (2025-12-26): Initial release

Converted and distributed by TomeVault — claim your Tome and manage your conversions.