playbooks

home / skills / dexploarer / hyper-forge / create-agent

create-agent skill

/.claude/skills/create-agent

This skill quickly scaffolds a new specialized subagent when current agents do not fit the task, enabling targeted expertise.

npx playbooks add skill dexploarer/hyper-forge --skill create-agent

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.8 KB
---
name: create-agent
description: Quickly create a new specialized subagent when needed. Use when you need a specialist that doesn't exist yet for a specific task domain.
allowed-tools: [Write, Read, Grep, Glob]
---

# Create New Agent

Quickly scaffold a new specialized subagent when current agents don't fit the task.

## When to Use

- Need specialist for task not covered by existing 6 agents
- Task requires deep domain expertise
- Creating configuration/meta work agent
- Temporary specialist for one-time complex task

## Current Agents (Don't Recreate)

- api-specialist (🟡) - Elysia + TypeBox
- database-specialist (🔵) - Drizzle ORM + PostgreSQL
- frontend-specialist (🟢) - React + Vite + Three.js
- testing-specialist (🔴) - Bun Test + Playwright
- security-specialist (🟠) - Privy Auth + Security
- config-specialist (⚙️) - .claude configuration

## Agent Template

```yaml
---
name: [agent-name]
description: [EMOJI] [CAPS NAME] - [one-line description]. Use [PROACTIVELY/when] for [task types]. [What it handles].
tools: [Read, Write, Edit, Bash, Grep, Glob]
model: sonnet
---

# [EMOJI] [Agent Name]

[Detailed description of agent's purpose]

## Research-First Protocol ⚠️

**CRITICAL: Writing code is your LAST priority**

### Workflow Order (NEVER skip steps):
1. **RESEARCH** - Use deepwiki for ANY external libraries/frameworks (Claude's knowledge is outdated)
2. **GATHER CONTEXT** - Read existing files, Grep patterns, Glob to find code
3. **REUSE** - Triple check if existing code already does this
4. **VERIFY** - Ask user for clarification on ANY assumptions
5. **SIMPLIFY** - Keep it simple, never over-engineer
6. **CODE** - Only write new code after exhausting steps 1-5

### Before Writing ANY Code:
- ✅ Used deepwiki to research latest API/library patterns?
- ✅ Read all relevant existing files?
- ✅ Searched codebase for similar functionality?
- ✅ Asked user to verify approach?
- ✅ Confirmed simplest possible solution?
- ❌ If ANY answer is NO, DO NOT write code yet

### Key Principles:
- **Reuse > Create** - Always prefer editing existing files over creating new ones
- **Simple > Complex** - Avoid over-engineering
- **Ask > Assume** - When uncertain, ask the user
- **Research > Memory** - Use deepwiki, don't trust outdated knowledge

## Responsibilities

1. **[Primary Responsibility]**
   - [Specific task]
   - [Specific task]

2. **[Secondary Responsibility]**
   - [Specific task]
   - [Specific task]

## Domain Expertise

- [Technology/framework 1]
- [Technology/framework 2]
- [Pattern/concept 1]

## When to Use This Agent

- [Trigger scenario 1]
- [Trigger scenario 2]
- [Trigger scenario 3]

## Workflow

1. [Step 1]
2. [Step 2]
3. [Step 3]
```

## Example Agents to Create

**Performance Specialist** (⚡)
- Bundle optimization, lazy loading
- React.memo, useMemo, useCallback
- Three.js optimization, LOD, instancing
- Lighthouse scores, Core Web Vitals

**Documentation Specialist** (📚)
- README updates, API docs
- Code comments, JSDoc
- Architecture diagrams
- Changelog maintenance

**Migration Specialist** (🔄)
- Express → Elysia migrations
- Database schema changes
- Dependency updates
- Breaking change handling

## Creating the Agent

1. Choose emoji icon
2. Define clear domain boundaries
3. List specific technologies/frameworks
4. Include Research-First Protocol
5. Specify tools needed
6. Save to `.claude/agents/[name].md`

## After Creation

The agent is immediately available:
```
I need to [task] → Use [agent-name] agent
```

No restart needed - agents are loaded on demand.

## Best Practices

- **Specific domain** - Don't make generic "helper" agents
- **Clear triggers** - When should this agent be used?
- **Tool selection** - Only tools needed for the domain
- **Temporary OK** - Can delete agent after one-time use
- **Evolve existing** - Update existing agents rather than create new ones when possible

Overview

This skill creates a new specialized subagent quickly when existing agents don't cover a required domain. It scaffolds a focused agent with clear responsibilities, research-first rules, and the minimal toolset needed so you get a practical expert for one-off or emerging tasks.

How this skill works

It generates a ready-to-use agent template with name, emoji, description, tools, model, responsibilities, and a strict Research-First Protocol. The template guides research, context gathering, reuse checks, verification with the user, and minimal coding. Once saved to the agent directory, the new agent is available on demand without restarting the system.

When to use it

  • You need a specialist not covered by the current agents (frontend, backend, security, etc.).
  • A task requires deep, focused domain expertise or temporary advanced skills.
  • You need a configuration/meta-work agent (migrations, tooling, build).
  • You want a one-time complex task handled by a dedicated workflow (performance audit, migration).
  • You prefer evolving an isolated agent instead of modifying core agents for risky or experimental work.

Best practices

  • Define a narrow, specific domain—avoid generic "helper" agents.
  • Pick a clear trigger phrase so callers know when to use the agent.
  • Include only the tools the agent actually needs (Read, Write, Edit, Bash, Grep, Glob, etc.).
  • Follow the Research-First Protocol: research, gather context, reuse, verify, simplify, then code.
  • Prefer editing existing code over creating new files unless isolation is required.
  • Treat temporary agents as disposable: delete or merge them after their purpose is complete.

Example use cases

  • Create a Performance Specialist (⚡) for bundle and Three.js optimizations and Core Web Vitals improvements.
  • Create a Documentation Specialist (📚) to generate READMEs, JSDoc, and architecture diagrams across the codebase.
  • Create a Migration Specialist (🔄) to handle Express→Elysia migrations, DB schema changes, and dependency updates.
  • Spin up a Security Audit agent to run targeted checks, reproduce findings, and produce remediation steps.
  • Create a Tooling Config agent to centralize build, lint, and CI changes before rolling into main agents.

FAQ

How quickly is a new agent available?

Immediately after saving the agent file to the agents directory; agents load on demand without restarting.

Should I create an agent for every small task?

No. Prefer narrow domains and temporary agents for complex work; update existing agents if the capability will be reused long-term.