agent-creator

Authoritative templates and scaffolding for creating agent system prompts (primary agents and subagents).This skill should be used when creating new agents, reviewing existing agent prompts for templatecompliance, verifying agent structure, or extracting knowledge into agent prompts. Contains YAMLtemplates with section-by-section instructions and scaffolding scripts for generating skeleton files.

⭐13stars🔀0forks📁View on GitHub🕐Updated Dec 29, 2025⬇️1downloads

When & Why to Use This Skill

The Agent Creator skill provides authoritative YAML templates and scaffolding scripts for building high-quality Claude agent system prompts. It streamlines the development of both primary orchestrator agents and specialized subagents by ensuring structural consistency, compliance with best practices, and standardized variable notation, making it an essential tool for developers building complex agentic workflows.

Use Cases

  • Standardizing Agent Structure: Use authoritative YAML templates to define consistent sections like Role Definition, Philosophy, and Multi-phase Workflows for primary agents.
  • Rapid Subagent Scaffolding: Quickly generate skeleton files for specialized task-oriented subagents using provided 'just' recipes or Python scripts to accelerate development.
  • Prompt Compliance Auditing: Review and verify existing agent prompts against templates to ensure all required metadata, frontmatter, and structural sections are correctly implemented.
  • Knowledge Extraction: Systematically organize and extract domain expertise into structured agent prompt sections using predefined instructions and templates.
  • Variable Notation Standardization: Implement consistent variable usage (e.g., using double curly braces {{VARIABLE_NAME}}) across complex agent systems to align with LLM training patterns and improve reliability.
nameagent-creator
description|

Agent Creator

This skill provides authoritative templates and tools for creating agent system prompts.

When to Use This Skill

  • Creating new primary agents or subagents
  • Reviewing existing agent prompts for template compliance
  • Verifying agent structure against templates
  • Extracting knowledge into agent prompts (need to know valid section names)
  • Understanding what sections an agent should have

Agent Types

Primary Agents

Full-featured agents that may orchestrate subagents. They have:

  • Complete identity (Role Definition, Who You Are/NOT, Philosophy)
  • Cognitive approach (When to Think Deeply, Analysis Mindset)
  • Orchestration patterns (if they spawn subagents)
  • Knowledge Base with domain expertise
  • Multi-phase Workflow
  • Learned Constraints

Template: references/primary-agent.yaml

Subagents

Focused specialists spawned by primary agents via Task tool. They have:

  • Narrow identity (Opening Statement)
  • Core Responsibilities (3-4 focused tasks)
  • Domain Strategy
  • Structured Output Format
  • Execution Boundaries

Template: references/subagent.yaml

Scripts

Execute scaffolding via justfile or directly with uv:

just -f {base_dir}/justfile <recipe> [args...]
Recipe Arguments Description
scaffold-primary name path Create primary agent skeleton
scaffold-subagent name path Create subagent skeleton

Direct Execution

uv run {base_dir}/scripts/scaffold_agent.py <type> <name> --path <path>
Argument Description
type primary or subagent
name Agent name (kebab-case)
--path Directory to create agent file

Examples

# Create a primary agent
just -f {base_dir}/justfile scaffold-primary my-agent .opencode/agent

# Create a subagent
just -f {base_dir}/justfile scaffold-subagent code-analyzer .opencode/agent

# Direct execution
uv run {base_dir}/scripts/scaffold_agent.py primary my-agent --path .opencode/agent

Template Reference

The YAML templates in references/ are the authoritative source for agent structure.

Each template contains:

  • frontmatter: Required and optional metadata fields
  • sections: Ordered list of sections with:
    • id: Unique section identifier
    • title: Section heading
    • type: Content type (text, bullet-list, structured, etc.)
    • instruction: Detailed guidance on what to write
    • template: Example format/structure
    • optional: Whether section can be omitted

Reading Templates

To understand what an agent section should contain:

  1. Read the appropriate template from references/
  2. Find the section by id or title
  3. Follow the instruction field for guidance
  4. Use the template field as a structural example

Domain Patterns

Variable Notation Standard

Apply consistent variable notation across all prompts:

Assignment formats:

  • Static: VARIABLE_NAME: "fixed-value"
  • Dynamic: VARIABLE_NAME: $ARGUMENTS
  • Parsing: VARIABLE_NAME: [description-of-what-to-extract]

Usage in instructions:

  • Always: {{VARIABLE_NAME}} (double curly braces)
  • Never: $VARIABLE_NAME, [[VARIABLE_NAME]], or bare VARIABLE_NAME

Rationale: {{}} notation matches LLM training on template systems (Jinja2, Handlebars, Mustache). It's unambiguous and visually clear.

Workflow Integration

When Prompter creates an agent:

  1. Analyze plan - Identify requirements
  2. Determine type - Primary (orchestrator) or Subagent (specialist)
  3. Scaffold - Run scaffolding script to create skeleton
  4. Reference template - Read YAML for section instructions
  5. Fill sections - Work through todo list, section by section
  6. Consider skills - Does this agent need domain expertise externalized?

The scaffolding creates the structure; the templates guide the content.