Create meta prompts, meta agents, and meta skills that build other agentic components. Use when scaling agentic layer development, creating generators/templates, or implementing "build the system that builds the system" patterns.
Creates meta-level generators that produce other agentic components (prompts, agents, skills). Use when building 4+ similar components or establishing reusable templates for scaling agentic development.
/plugin marketplace add melodic-software/claude-code-plugins/plugin install google-ecosystem@melodic-softwareThis skill is limited to using the following tools:
Guide for creating meta-level agentic components that generate other components.
"Build the system that builds the system. Do not work on the application layer."
Meta agentics provide multiplicative leverage:
┌─────────────────────────────────────────────────────┐
│ Level 3: Meta-Meta (rarely needed) │
│ • Generators that create generators │
└──────────────────────┬──────────────────────────────┘
│
┌──────────────────────▼──────────────────────────────┐
│ Level 2: Meta Components │
│ • Meta prompts (prompt generators) │
│ • Meta agents (agent builders) │
│ • Meta skills (skill scaffolders) │
└──────────────────────┬──────────────────────────────┘
│
┌──────────────────────▼──────────────────────────────┐
│ Level 1: Standard Components │
│ • Domain prompts │
│ • Specialized agents │
│ • Task-specific skills │
└──────────────────────┬──────────────────────────────┘
│
┌──────────────────────▼──────────────────────────────┐
│ Level 0: Application Layer │
│ • End-user features │
│ • Business logic │
└─────────────────────────────────────────────────────┘
A meta prompt is a prompt that generates other prompts.
---
description: Generate a {type} prompt for {purpose}
argument-hint: <name> [options...]
---
# Meta Prompt: {Type} Generator
Generate well-structured {type} prompts following established patterns.
## Arguments
- `$1`: Name for the generated prompt (required)
- `$2`: Primary purpose/domain (optional)
- `$ARGUMENTS`: Additional context
## Template Structure
The generated prompt will follow this structure:
### YAML Frontmatter
```yaml
---
description: {Generated based on purpose}
argument-hint: {Appropriate for prompt type}
---
```
### Sections to Include
1. **Purpose**: Clear statement of what prompt does
2. **Arguments**: Input parameters with defaults
3. **Workflow**: Step-by-step instructions
4. **Output Format**: Expected deliverable structure
5. **Notes**: Important considerations
## Generation Rules
1. Use imperative mood ("Do X", not "You should do X")
2. Include concrete examples
3. Specify output format explicitly
4. Add validation/verification steps
5. Keep under {line_limit} lines
## Output
Write the generated prompt to: `.claude/commands/{name}.md`
Report:
- Generated prompt name
- Location
- Key sections included
A meta agent creates other agents.
---
name: meta-agent
description: Create new specialized agents following established patterns and best practices.
tools: Read, Write, Glob, Grep
model: opus
---
# Meta Agent: Agent Builder
Create well-structured agents following Claude Code patterns.
## Input Requirements
When invoked, expect:
- Agent name (kebab-case)
- Agent purpose (1-2 sentences)
- Required tools (list)
- Model preference (opus|sonnet|haiku)
- Domain context
## Agent Template
```yaml
---
name: {agent-name}
description: {Purpose description under 200 chars}
tools: {Tool1, Tool2, ...}
model: {opus|sonnet|haiku}
---
# {Agent Name}
{Detailed purpose and when to use this agent}
## Capabilities
- Capability 1
- Capability 2
## Workflow
### Step 1: {First Step}
{Instructions}
### Step 2: {Second Step}
{Instructions}
## Output Format
{Expected output structure}
## Constraints
- Constraint 1
- Constraint 2
```
## Generation Workflow
1. **Analyze Request**: Understand agent purpose
2. **Select Tools**: Choose minimal required tools
3. **Choose Model**:
- haiku: Simple, fast tasks
- sonnet: Balanced reasoning
- opus: Complex, critical tasks
4. **Design Workflow**: Create step-by-step process
5. **Write Agent**: Generate agent file
6. **Register**: Update plugin.json if needed
## Validation
Before completing:
- [ ] Description under 200 characters
- [ ] Tools are minimal and appropriate
- [ ] Model matches task complexity
- [ ] Workflow is complete and actionable
A meta skill creates other skills.
---
name: meta-skill
description: Create new skills following Claude Code patterns with proper YAML frontmatter, structure, and documentation.
version: 1.0.0
allowed-tools: Read, Write, Glob, Grep
tags: [meta, skill, generator, scaffolder]
---
# Meta Skill: Skill Generator
Create well-structured skills following established patterns.
## Skill Template
```yaml
---
name: {skill-name}
description: {Clear description of what skill does and when to use it}
version: 1.0.0
allowed-tools: {Tool1, Tool2, ...}
tags: [{tag1}, {tag2}, ...]
---
# {Skill Name}
{Introduction and purpose}
## When to Use
- Use case 1
- Use case 2
## Key Concepts
### Concept 1
{Explanation}
### Concept 2
{Explanation}
## Patterns
### Pattern Name
{Description and example}
## Anti-Patterns
| Anti-Pattern | Problem | Solution |
| --- | --- | --- |
| ... | ... | ... |
## Related Skills
- `skill-1`: Relationship
- `skill-2`: Relationship
```
## Skill Generation Rules
1. **Naming**: Use noun-phrases (kebab-case)
2. **Description**: Under 200 chars, starts with action verb
3. **Tags**: 4-8 relevant keywords
4. **Tools**: Minimal set needed
5. **Structure**: Consistent sections
## Directory Structure
```text
skills/{skill-name}/
SKILL.md # Main skill file
references/ # Optional supporting docs
scripts/ # Optional automation
```
Before creating a meta component, identify:
The template should:
The generator should:
Validate by:
| Situation | Create Meta? | Reason |
|---|---|---|
| Need 1 component | No | Direct creation faster |
| Need 2-3 similar | Maybe | Depends on complexity |
| Need 4+ similar | Yes | Meta pays off |
| Establishing patterns | Yes | Encodes best practices |
| Onboarding others | Yes | Ensures consistency |
| Anti-Pattern | Problem | Solution |
|---|---|---|
| Over-abstraction | Meta-meta-meta | Stop at 2 levels |
| Rigid templates | Can't handle variations | Build in flexibility |
| No examples | Users don't understand | Include concrete examples |
| No validation | Bad outputs generated | Always validate results |
.claude/commands/meta_prompt.md # Creates new prompts
.claude/agents/meta-agent.md # Creates new agents
.claude/skills/meta-skill/SKILL.md # Creates new skills
tac/agents/prompt-generator.md # Generates prompts
tac/agents/agent-builder.md # Builds agents
tac/skills/tool-design/SKILL.md # Designs tools
Meta components provide multiplicative returns:
Without meta:
10 agents × 30 min each = 300 minutes
With meta:
1 meta-agent × 60 min + 10 generations × 5 min = 110 minutes
Savings: 63%
The more components you need, the more meta pays off.
agent-expert-creation: Self-improving expertstemplate-meta-prompt-creation: Level 6 promptsprompt-level-selection: Choosing prompt complexityLast Updated: 2025-12-15
This skill should be used when the user asks to "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "agent tools", "agent colors", "autonomous agent", or needs guidance on agent structure, system prompts, triggering conditions, or agent development best practices for Claude Code plugins.
This skill should be used when the user asks to "create a slash command", "add a command", "write a custom command", "define command arguments", "use command frontmatter", "organize commands", "create command with file references", "interactive command", "use AskUserQuestion in command", or needs guidance on slash command structure, YAML frontmatter fields, dynamic arguments, bash execution in commands, user interaction patterns, or command development best practices for Claude Code.
This skill should be used when the user asks to "create a hook", "add a PreToolUse/PostToolUse/Stop hook", "validate tool use", "implement prompt-based hooks", "use ${CLAUDE_PLUGIN_ROOT}", "set up event-driven automation", "block dangerous commands", or mentions hook events (PreToolUse, PostToolUse, Stop, SubagentStop, SessionStart, SessionEnd, UserPromptSubmit, PreCompact, Notification). Provides comprehensive guidance for creating and implementing Claude Code plugin hooks with focus on advanced prompt-based hooks API.