majiayu000/claude-skill-registry-agent-creator-enhanced-skill-agent-creator
Creates specialized AI agents with optimized system prompts using the official 4-phase SOP methodology from Desktop .claude-flow, combined with evidence-based prompting techniques and Claude Agent SDK implementation. Use this skill when creating production-ready agents for specific domains, workflows, or tasks requiring consistent high-quality performance with deeply embedded domain knowledge.
This is a copy. The original lives at comeonoliver/agent-creator.
npx skills add https://github.com/majiayu000/claude-skill-registry --skill agent-creatorThis skill provides the official comprehensive framework for creating specialized AI agents, integrating the proven 4-phase methodology from Desktop .claude-flow with Claude Agent SDK implementation and evidence-based prompting techniques.
Use agent-creator for:
Source: Desktop .claude-flow/ official SOP documentation
Total Time: 2.5-4 hours per agent (first-time), 1.5-2 hours (speed-run)
This methodology was developed through systematic reverse engineering of fog-compute agent creation and validated through production use.
Objective: Deep domain understanding through systematic research, not assumptions.
Activities:
Validation Gate:
Outputs:
Objective: Identify the cognitive expertise domains activated when you reason about this agent's tasks.
Activities:
# Agent Specification: [Name]
## Role & Expertise
- Primary role: [Specific title]
- Expertise domains: [List activated domains]
- Cognitive patterns: [Heuristics used]
## Core Capabilities
1. [Capability with specific examples]
2. [Capability with specific examples]
...
## Decision Frameworks
- When X, do Y because Z
- Always check A before B
- Never skip validation of C
## Quality Standards
- Output must meet [criteria]
- Performance measured by [metrics]
- Failure modes to prevent: [list]
Validation Gate:
Outputs:
Objective: Transform specification into production-ready base system prompt.
Activities:
# [AGENT NAME] - SYSTEM PROMPT v1.0
## 🎭 CORE IDENTITY
I am a **[Role Title]** with comprehensive, deeply-ingrained knowledge of [domain]. Through systematic reverse engineering and domain expertise, I possess precision-level understanding of:
- **[Domain Area 1]** - [Specific capabilities from Phase 2]
- **[Domain Area 2]** - [Specific capabilities from Phase 2]
- **[Domain Area 3]** - [Specific capabilities from Phase 2]
My purpose is to [primary objective] by leveraging [unique expertise].
## 📋 UNIVERSAL COMMANDS I USE
**File Operations**:
- /file-read, /file-write, /glob-search, /grep-search
WHEN: [Specific situations from domain analysis]
HOW: [Exact patterns]
**Git Operations**:
- /git-status, /git-commit, /git-push
WHEN: [Specific situations]
HOW: [Exact patterns]
**Communication & Coordination**:
- /memory-store, /memory-retrieve
- /agent-delegate, /agent-escalate
WHEN: [Specific situations]
HOW: [Exact patterns with namespace conventions]
## 🎯 MY SPECIALIST COMMANDS
[List role-specific commands with exact syntax and examples]
## 🔧 MCP SERVER TOOLS I USE
**Claude Flow MCP**:
- mcp__claude-flow__agent_spawn
WHEN: [Specific coordination scenarios]
HOW: [Exact function call patterns]
- mcp__claude-flow__memory_store
WHEN: [Cross-agent data sharing]
HOW: [Namespace pattern: agent-role/task-id/data-type]
**[Other relevant MCP servers from Phase 1]**
## 🧠 COGNITIVE FRAMEWORK
### Self-Consistency Validation
Before finalizing deliverables, I validate from multiple angles:
1. [Domain-specific validation 1]
2. [Domain-specific validation 2]
3. [Cross-check with standards]
### Program-of-Thought Decomposition
For complex tasks, I decompose BEFORE execution:
1. [Domain-specific decomposition pattern]
2. [Dependency analysis]
3. [Risk assessment]
### Plan-and-Solve Execution
My standard workflow:
1. PLAN: [Domain-specific planning]
2. VALIDATE: [Domain-specific validation]
3. EXECUTE: [Domain-specific execution]
4. VERIFY: [Domain-specific verification]
5. DOCUMENT: [Memory storage patterns]
## 🚧 GUARDRAILS - WHAT I NEVER DO
[From Phase 2 failure modes and edge cases]
**[Failure Category 1]**:
❌ NEVER: [Dangerous pattern]
WHY: [Consequences from domain knowledge]
WRONG:
[Bad example]
CORRECT:
[Good example]
## ✅ SUCCESS CRITERIA
Task complete when:
- [ ] [Domain-specific criterion 1]
- [ ] [Domain-specific criterion 2]
- [ ] [Domain-specific criterion 3]
- [ ] Results stored in memory
- [ ] Relevant agents notified
## 📖 WORKFLOW EXAMPLES
### Workflow 1: [Common Task Name from Phase 1]
**Objective**: [What this achieves]
**Step-by-Step Commands**:
Step 1: [Action]
COMMANDS:
OUTPUT: [Expected]
VALIDATION: [Check]
Step 2: [Next Action]
COMMANDS:
OUTPUT: [Expected]
VALIDATION: [Check]
**Timeline**: [Duration]
**Dependencies**: [Prerequisites]
For each technique (from existing agent-creator skill):
Integrate these naturally into the agent's methodology.
From Phase 2 failure modes, create explicit guardrails:
Validation Gate:
Outputs:
Objective: Reverse-engineer exact implementation patterns and document with precision.
Activities:
For technical agents, extract EXACT patterns from codebase:
## Code Patterns I Recognize
### Pattern: [Name]
**File**: `path/to/file.py:123-156`
class ExamplePattern:
def __init__(
self,
param1: Type = default, # Line 125: Exact default
param2: Type = default # Line 126: Exact default
):
pass
**When I see this pattern, I know**:
- [Specific insight about architecture]
- [Specific constraint or requirement]
- [Common mistake to avoid]
From experience and domain knowledge:
## Critical Failure Modes
### Failure: [Name]
**Severity**: Critical/High/Medium
**Symptoms**: [How to recognize]
**Root Cause**: [Why it happens]
**Prevention**:
❌ DON'T: [Bad pattern]
✅ DO: [Good pattern with exact code]
**Detection**:
[command]
Document exact MCP tool usage:
## MCP Integration Patterns
### Pattern: Cross-Agent Data Sharing
// Exact pattern for storing outputs
mcp__claude-flow__memory_store({
key: "marketing-specialist/campaign-123/audience-analysis",
value: {
segments: [...],
targeting: {...},
confidence: 0.89
},
ttl: 86400
})
**Namespace Convention**:
- Format: `{agent-role}/{task-id}/{data-type}`
- Example: `backend-dev/api-v2/schema-design`
Define what to track:
## Performance Metrics I Track
Task Completion:
Quality:
Efficiency:
These metrics enable continuous improvement.
Validation Gate:
Outputs:
Combining 4-phase SOP with existing best practices:
Total Time: 3.5-5.5 hours (first-time), 2-3 hours (speed-run)
Once system prompt is finalized, implement with SDK:
import { query, tool } from '@anthropic-ai/claude-agent-sdk';
import { z } from 'zod';
// Custom domain-specific tools
const domainTool = tool({
name: 'domain_operation',
description: 'Performs domain-specific operation',
parameters: z.object({
param: z.string()
}),
handler: async ({ param }) => {
// Implementation from Phase 4
return { result: 'data' };
}
});
// Agent configuration
for await (const message of query('Perform domain task', {
model: 'claude-sonnet-4-5',
systemPrompt: enhancedPromptV2, // From Phase 4
permissionMode: 'acceptEdits',
allowedTools: ['Read', 'Write', 'Bash', domainTool],
mcpServers: [{
command: 'npx',
args: ['claude-flow@alpha', 'mcp', 'start'],
env: { ... }
}],
settingSources: ['user', 'project']
})) {
console.log(message);
}
from claude_agent_sdk import query, tool, ClaudeAgentOptions
import asyncio
@tool()
async def domain_operation(param: str) -> dict:
"""Domain-specific operation from Phase 4."""
# Implementation
return {"result": "data"}
async def run_agent():
options = ClaudeAgentOptions(
model='claude-sonnet-4-5',
system_prompt=enhanced_prompt_v2, # From Phase 4
permission_mode='acceptEdits',
allowed_tools=['Read', 'Write', 'Bash', domain_operation],
mcp_servers=[{
'command': 'npx',
'args': ['claude-flow@alpha', 'mcp', 'start']
}],
setting_sources=['user', 'project']
)
async for message in query('Perform domain task', **options):
print(message)
asyncio.run(run_agent())
From existing agent-creator skill, enhanced with 4-phase methodology:
Phase 1 Focus: Evidence evaluation patterns, data quality standards
Phase 2 Focus: Analytical heuristics, validation frameworks
Phase 3 Focus: Self-consistency checking, confidence calibration
Phase 4 Focus: Statistical validation code, error detection patterns
Phase 1 Focus: Quality criteria, template patterns
Phase 2 Focus: Creative heuristics, refinement cycles
Phase 3 Focus: Plan-and-solve frameworks, requirement tracking
Phase 4 Focus: Generation patterns, quality validation code
Phase 1 Focus: Problem patterns, debugging workflows
Phase 2 Focus: Hypothesis generation, systematic testing
Phase 3 Focus: Program-of-thought decomposition, evidence tracking
Phase 4 Focus: Detection scripts, root cause analysis patterns
Phase 1 Focus: Workflow patterns, dependency management
Phase 2 Focus: Coordination heuristics, error recovery
Phase 3 Focus: Plan-and-solve with dependencies, progress tracking
Phase 4 Focus: Orchestration code, retry logic, escalation paths
From existing framework + SOP enhancements:
Phase 1 (Analysis):
Phase 2 (Expertise Extraction):
Phase 3 (Architecture):
Phase 4 (Enhancement):
Total: 2 hours for experienced creators with templates
See: docs/agent-architecture/agents-rewritten/MARKETING-SPECIALIST-AGENT.md
Phase 1 Output: Marketing domain analysis, tools (Google Analytics, SEMrush, etc.)
Phase 2 Output: Marketing expertise (CAC, LTV, funnel optimization, attribution)
Phase 3 Output: Base prompt with 9 specialist commands
Phase 4 Output: Campaign workflow patterns, A/B test validation, ROI calculations
Result: Production-ready agent with deeply embedded marketing expertise
This enhanced agent-creator skill combines:
Use this methodology to create all 90 specialist agents with:
Next: Begin agent rewrites using this enhanced methodology.
Take majiayu000/claude-skill-registry-agent-creator-enhanced-skill-agent-creator from the repository into ~/.claude/skills for personal
use, or into .claude/skills inside a project.
The agent identifies a skill by the name field in its header. Two skills with the
same name cannot sit side by side — one of them will be ignored.