메뉴
Creates and registers templates for agents, skills, workflows, hooks, and code patterns. Handles post-creation catalog updates, consuming skill integration, and README registration. Use when creating new template types or standardizing patterns.
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/oimiragieo/agent-studio --skill template-creator명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
SOC 직업 분류 기준
SKILL.md 표시 중
| name | template-creator |
| description | Creates and registers templates for agents, skills, workflows, hooks, and code patterns. Handles post-creation catalog updates, consuming skill integration, and README registration. Use when creating new template types or standardizing patterns. |
| version | 2.2.0 |
| category | creator |
| model | sonnet |
| invoked_by | both |
| user_invocable | true |
| tools | ["Read","Write","Edit","Bash","Glob","Grep"] |
| assigned_agents | ["planner","architect","developer"] |
| triggers | ["create template","new template","template for"] |
| dependencies | ["research-synthesis"] |
| output_paths | [".claude/templates/"] |
| best_practices | ["Include all required fields with placeholders","Add documentation comments in templates","Version templates for tracking changes","Include validation examples","Use consistent placeholder format","Update template-catalog.md after every creation","Sanitize spawn template placeholders"] |
| error_handling | graceful |
| streaming | supported |
| output_location | .claude/templates/ |
| verified | true |
| lastVerifiedAt | 2026-02-28 |
| source | builtin |
| trust_score | 100 |
| provenance_sha | 2464fc762fb36f07 |
Mode: Cognitive/Prompt-Driven -- No standalone utility script; use via agent context.
Creates, validates, and registers templates for the multi-agent orchestration framework.
+==============================================================+
| MANDATORY: Research-Synthesis MUST be invoked BEFORE |
| this skill. Invoke: Skill({ skill: "research-synthesis" }) |
| FAILURE TO RESEARCH = UNINFORMED TEMPLATE = REJECTED |
+==============================================================+
| |
| DO NOT WRITE TEMPLATE FILES DIRECTLY! |
| |
| This includes: |
| - Copying archived templates |
| - Restoring from _archive/ backup |
| - "Quick" manual creation |
| |
| WHY: Direct writes bypass MANDATORY post-creation steps: |
| 1. Template catalog update (template NOT discoverable) |
| 2. README.md update (template INVISIBLE to consumers) |
| 3. Consuming skill update (template NEVER used) |
| 4. CLAUDE.md update (if user-invocable) |
| |
| RESULT: Template EXISTS in filesystem but is NEVER USED. |
| |
| ENFORCEMENT: unified-creator-guard.cjs blocks direct |
| template writes. Override: CREATOR_GUARD=off (DANGEROUS) |
| |
| ALWAYS invoke this skill properly: |
| Skill({ skill: "template-creator" }) |
| |
+==============================================================+
After creating ANY template, you MUST update:
.claude/templates/README.md - Add template entry.claude/context/artifacts/catalogs/template-catalog.md - Add catalog entry.claude/context/memory/learnings.md - Record creationVerification:
grep "<template-name>" .claude/templates/README.md || echo "ERROR: README NOT UPDATED!"
grep .claude/context/artifacts/catalogs/template-catalog.md ||
WHY: Templates not in the catalog are invisible to other creators and will never be used.
Templates ensure consistency across the multi-agent framework. This skill creates templates for:
spawn-template-resolver.cjsCore principle: Templates are the DNA of the system. Consistent templates produce consistent, predictable agents and skills.
Always:
Exceptions:
| Type | Location | Count | Purpose | Key Consumers |
|---|---|---|---|---|
| Spawn | .claude/templates/spawn/ | 4 | Agent spawn prompt templates | router, spawn-prompt-assembler |
| Agent | .claude/templates/agents/ | 2 | Agent definition boilerplate | agent-creator |
| Skill | .claude/templates/skills/ | 1 | Skill definition boilerplate | skill-creator |
| Workflow | .claude/templates/workflows/ | 1 | Workflow definition boilerplate | workflow-creator |
| Report | .claude/templates/reports/ | 5 | Report document templates | qa, developer, researcher |
| Code Style | .claude/templates/code-styles/ | 3 | Language style guides | developer, code-reviewer |
| Document | .claude/templates/ (root) | 8+ | General document templates (ADR, spec) | planner, architect, qa |
Cross-Reference: See .claude/context/artifacts/catalogs/template-catalog.md for the complete inventory (28 active templates). For spawn template resolution logic, see .claude/lib/spawn/spawn-template-resolver.cjs.
Critical Security Requirements:
.claude/templates/...), never absolute pathsnul, con, prn, aux, com1-com9, lpt1-lpt9{{PLACEHOLDER}} tokens in prompt: fields MUST reference sanitizeSubstitutionValue() from prompt-factory.cjs for value sanitization. Unsanitized placeholders in spawn prompts create a prompt injection surface. Do NOT place {{PLACEHOLDER}} tokens where user-provided input is directly substituted without sanitization.eval(), exec(), Function(), or other code execution patternsEnforcement: unified-creator-guard.cjs hook blocks direct template writes (default: block mode).
NO TEMPLATE WITHOUT PLACEHOLDER DOCUMENTATION
Every {{PLACEHOLDER}} must have a corresponding comment explaining:
No exceptions:
Per CLAUDE.md Section 3 requirement, invoke research-synthesis BEFORE template creation:
Skill({ skill: 'research-synthesis' });
Research focuses for templates:
Search existing templates: Glob: .claude/templates/**/*.md
Review template catalog: Read .claude/context/artifacts/catalogs/template-catalog.md
Check if similar template already exists in the ecosystem
Research domain-specific template structures (minimum 2 queries required):
WebSearch({ query: 'best <domain/topic name> template report or files 2026' });
WebSearch({ query: 'industry standard <template type> format <domain/tool> 2026' });
BLOCKING: Template creation CANNOT proceed without research-synthesis invocation.
Before proceeding with creation, run the 3-layer duplicate check:
const { checkDuplicate } = require('.claude/lib/creation/duplicate-detector.cjs');
const result = checkDuplicate({
artifactType: 'template',
name: proposedName,
description: proposedDescription,
keywords: proposedKeywords || [],
});
Handle results:
EXACT_MATCH: Stop creation. Route to template-updater skill instead: Skill({ skill: 'template-updater' })REGISTRY_MATCH: Warn user — artifact is registered but file may be missing. Investigate before creating. Ask user to confirm.SIMILAR_FOUND: Display candidates with scores. Ask user: "Similar artifact(s) exist. Continue with new creation or update existing?"NO_MATCH: Proceed to next step.Override: If user explicitly passes --force, skip this check entirely.
Before proceeding with creation, run the ecosystem companion check:
companion-check.cjs from .claude/lib/creators/companion-check.cjscheckCompanions("template", "{template-name}") to identify companion artifactsThis step is informational (does not block creation) but ensures the full artifact ecosystem is considered.
Analyze the request:
Example analysis:
Template Request: "Create a template for security audit reports"
- Type: Report
- Purpose: Standardize security audit report structure
- Required: findings, severity_levels, recommendations
- Optional: compliance_framework, remediation_timeline
- Rules: severity must be CRITICAL|HIGH|MEDIUM|LOW
- Consumers: security-architect, qa
Classify the template to determine output path and validation rules:
| Type | Output Path | Key Fields | Validation Focus |
|---|---|---|---|
| Spawn | .claude/templates/spawn/ | subagent_type, prompt, model, task_id | TaskUpdate protocol, allowed_tools, model |
| Agent | .claude/templates/agents/ | name, description, tools, skills, model, enforcement_hooks | Frontmatter completeness, alignment sections |
| Skill | .claude/templates/skills/ | name, version, tools, invoked_by | SKILL.md structure, memory protocol |
| Workflow | .claude/templates/workflows/ | phases, agents, dependencies | Phase ordering, agent references |
| Report | .claude/templates/reports/ | type, findings, recommendations | Finding severity, evidence requirements |
| Code Style | .claude/templates/code-styles/ | language, conventions, examples | Convention clarity, example quality |
| Document | .claude/templates/ (root) | varies by template type | Section completeness |
BEFORE constructing the output path, validate the template name.
Template name MUST match this regex:
/^[a-z0-9][a-z0-9-]*[a-z0-9]$/
Validation rules:
/, \), no .., no special charactersnul, con, prn, aux, com1-com9, lpt1-lpt9)Rejection examples:
REJECTED: "../hooks/malicious-hook" (path traversal)
REJECTED: "My Template" (spaces, uppercase)
REJECTED: "-leading-hyphen" (starts with hyphen)
REJECTED: "template_with_underscores" (underscores not allowed)
ACCEPTED: "security-audit-report" (valid kebab-case)
ACCEPTED: "agent-template-v2" (valid with version)
Based on the template type classification from Step 2, construct the output path:
.claude/templates/<category>/<validated-template-name>.md
Where <category> is one of: spawn/, agents/, skills/, workflows/, reports/, code-styles/, or root level (no category subdirectory).
Validate the resolved path:
.claude/templates/.. segments after normalization.mdDesign the template content following these standards:
| Placeholder Type | Format | Example |
|---|---|---|
| Required field | {{FIELD_NAME}} | {{AGENT_NAME}} |
| Optional field | {{FIELD_NAME:default}} | {{MODEL:sonnet}} |
| Multi-line | {{FIELD_NAME_BLOCK}} | {{DESCRIPTION_BLOCK}} |
| List item | {{ITEM_N}} | {{TOOL_1}}, {{TOOL_2}} |
---
# YAML Frontmatter with all required fields
name: { { NAME } }
description: { { DESCRIPTION } }
# ... other fields with documentation comments
---
# {{DISPLAY_NAME}}
## POST-CREATION CHECKLIST (BLOCKING - DO NOT SKIP)
<!-- Always include blocking checklist -->
## Overview
{{OVERVIEW_DESCRIPTION}}
## Sections
<!-- Domain-specific sections -->
## Memory Protocol (MANDATORY)
<!-- Always include memory protocol -->
If creating a SPAWN template, you MUST also verify:
{{PLACEHOLDER}} tokens inside prompt: fields that accept unsanitized user inputsanitizeSubstitutionValue() from prompt-factory.cjs included in documentationallowed_tools array does not grant Task tool to non-orchestrator agentsIGNORE PREVIOUS, SYSTEM:, etc.) in template bodyAdd inline documentation for each placeholder:
---
# [REQUIRED] Unique identifier, lowercase-with-hyphens
name: { { AGENT_NAME } }
# [REQUIRED] Single line, describes what it does AND when to use it
# Example: "Reviews mobile app UX against Apple HIG. Use for iOS UX audits."
description: { { DESCRIPTION } }
# [OPTIONAL] Default: sonnet. Options: haiku, sonnet, opus
model: { { MODEL:sonnet } }
---
Write to the validated output path determined in Step 4:
Write: .claude/templates/<category>/<template-name>.md
Before proceeding to registration, verify ALL requirements:
Structural Validation:
[ ] YAML frontmatter is valid syntax
[ ] All required fields have placeholders
[ ] All placeholders follow {{UPPER_CASE}} naming convention
[ ] All placeholders have documentation comments
[ ] POST-CREATION CHECKLIST section present
[ ] Memory Protocol section present
[ ] Verification commands included
[ ] Example values provided where helpful
Security Validation (SEC-TC-007):
[ ] No secrets, credentials, or API keys in template content
[ ] No absolute file paths (use relative from PROJECT_ROOT)
[ ] No eval(), exec(), Function() or code execution patterns
[ ] No prompt override patterns ("IGNORE PREVIOUS", "SYSTEM:", etc.)
[ ] Template size under 50KB
Verification Commands:
# Check no unresolved placeholders from template-creator itself
grep "{{" <created-file> | head -5 # Should show only intended placeholders
# Check YAML frontmatter is present
head -50 <file> | grep -E "^---$" | wc -l # Should be 2
# Check required sections present
grep -E "^## Memory Protocol" <file> || echo "ERROR: Missing Memory Protocol!"
BLOCKING: Template must pass ALL validation checks before proceeding.
Update the template catalog to ensure the new template is discoverable.
Read current catalog:
cat .claude/context/artifacts/catalogs/template-catalog.md
Determine template category based on type:
spawn/), Creator (agents/, skills/, workflows/), Document (root), Report (reports/), Code Style (code-styles/)Add template entry in correct category section:
### <template-name>.md
| Field | Value |
| ------------------ | ------------------------------------------------- |
| **Path** | `.claude/templates/<category>/<template-name>.md` |
| **Category** | <Category> Templates |
| **Status** | active |
| **Used By Agents** | <agent-list> |
| **Used By Skills** | <skill-list> |
**Purpose:** <Purpose description>
Update Template Categories Summary table (totals row)
Verify update:
grep "<template-name>" .claude/context/artifacts/catalogs/template-catalog.md || echo "ERROR: CATALOG NOT UPDATED!"
Important: Use JSON.stringify() when constructing any JSON registry entries (SEC-TC-004). Never manually concatenate strings to build JSON. The location field MUST be validated to start with .claude/templates/ and contain no .. segments.
BLOCKING: Template must appear in catalog. Uncataloged templates are invisible.
After updating the catalog, update .claude/templates/README.md:
Entry format:
### {{Template Type}} Templates (`{{directory}}/`)
Use when {{use case}}.
**File:** `{{directory}}/{{template-name}}.md`
**Usage:**
1. Copy template to `{{target-path}}`
2. Replace all `{{PLACEHOLDER}}` values
3. {{Additional steps}}
Verification:
grep "<template-name>" .claude/templates/README.md || echo "ERROR: README NOT UPDATED - BLOCKING!"
BLOCKING: README must contain the template entry.
If the template is framework-significant or user-invocable:
Check if template needs CLAUDE.md entry:
If YES, add entry:
**{Template Name}:** `.claude/templates/{category}/{name}.md`
Verify:
grep "<template-name>" .claude/CLAUDE.md || echo "WARNING: Template not in CLAUDE.md (may be OK if internal-only)"
Note: Not all templates need CLAUDE.md entries. Only framework-significant ones (spawn templates, creator templates) require this step.
Templates exist to be consumed by creators and agents. After creation:
Identify consumers based on template type:
Update consuming skill/agent to reference the template:
**Available Templates:**
- See `.claude/templates/<category>/<template-name>.md` for standardized <type> template
Verify at least one consumer references the template:
grep -r "<template-name>" .claude/skills/ .claude/agents/ || echo "WARNING: No consumer references template"
WHY: Templates without consumers are dead on arrival. Every template MUST have at least one consuming skill or agent.
This step verifies the artifact is properly integrated into the ecosystem.
Before calling TaskUpdate({ status: "completed" }), run the post-creation validation:
Run the integration checklist:
node .claude/tools/cli/validate-integration.cjs .claude/templates/<category>/<template-name>.md
Verify exit code is 0 (all checks passed)
If exit code is 1 (one or more checks failed):
.claude/templates/README.mdtemplate-catalog.mdlearnings.mdOnly proceed when validation passes
This step is BLOCKING. Do NOT mark task complete until validation passes.
Why this matters: The Party Mode incident showed that fully-implemented artifacts can be invisible to the Router if integration steps are missed. This validation ensures no "invisible artifact" pattern.
Reference: .claude/workflows/core/post-creation-validation.md
All items MUST pass before template creation is complete:
[ ] Research-synthesis skill invoked (Step 0)
[ ] Existence check passed (no duplicate template)
[ ] Template name validates against /^[a-z0-9][a-z0-9-]*[a-z0-9]$/ (Step 3)
[ ] Template file created at .claude/templates/<category>/<name>.md
[ ] All placeholders use {{PLACEHOLDER_NAME}} format
[ ] All placeholders have documentation comments
[ ] POST-CREATION CHECKLIST section present in template
[ ] Memory Protocol section present in template
[ ] No hardcoded values (all configurable via placeholders)
[ ] No secrets, credentials, or absolute paths in template (SEC-TC-007)
[ ] No eval() or code execution patterns in template
[ ] template-catalog.md updated with structured entry (Step 8)
[ ] .claude/templates/README.md updated with template entry (Step 9)
[ ] CLAUDE.md updated if template is framework-significant (Step 10)
[ ] At least one consuming skill/agent references the template (Step 11)
[ ] Integration verification passed (Step 12)
[ ] Template tested with at least one real usage
[ ] Memory files updated (learnings.md)
BLOCKING: If ANY item fails, template creation is INCOMPLETE. Fix all issues before proceeding.
.claude/templates/{category}/ (spawn, agents, skills, workflows, reports, code-styles).claude/templates/_archive/.claude/context/artifacts/catalogs/template-catalog.mdtests/ (NOT in .claude/).claude/docs/@*.mdcd "$PROJECT_ROOT" || exit 1 for background tasks.claude/docs/SHELL-SECURITY-GUIDE.md.claude/templates/...), never absolute pathssanitizeSubstitutionValue() in prompt-factory.cjsThese rules are INVIOLABLE. Breaking them causes inconsistency across the framework.
1. NO TEMPLATE WITHOUT PLACEHOLDER DOCUMENTATION
- Every {{PLACEHOLDER}} must have an inline comment
- Comments explain valid values and examples
2. NO TEMPLATE WITHOUT POST-CREATION CHECKLIST
- Users must know what to do after using template
- Blocking steps prevent incomplete artifacts
3. NO TEMPLATE WITHOUT MEMORY PROTOCOL
- All templates must include Memory Protocol section
- Ensures artifacts created from template follow memory rules
4. NO TEMPLATE WITHOUT README UPDATE
- Templates README must document new template
- Undocumented templates are invisible
5. NO PLACEHOLDER WITHOUT NAMING CONVENTION
- Use {{UPPER_CASE_WITH_UNDERSCORES}}
- Never use lowercase or mixed case
6. NO OPTIONAL FIELD WITHOUT DEFAULT
- Format: {{FIELD:default_value}}
- Makes templates usable without full customization
7. NO TEMPLATE WITHOUT VERIFICATION COMMANDS
- Include commands to validate created artifacts
- Users can verify their work is correct
8. NO AGENT TEMPLATE WITHOUT ALIGNMENT SECTIONS
- Agent templates MUST include {{ENFORCEMENT_HOOKS}} placeholder section
- Agent templates MUST include {{RELATED_WORKFLOWS}} placeholder section
- Agent templates MUST include Output Standards block referencing workspace-conventions
- Reference: @HOOK_AGENT_MAP.md and @WORKFLOW_AGENT_MAP.md for archetype sets
9. NO TEMPLATE WITHOUT CATALOG ENTRY
- Every template MUST be registered in template-catalog.md
- Uncataloged templates are invisible to the system
- Verify: grep "<template-name>" .claude/context/artifacts/catalogs/template-catalog.md
10. NO TEMPLATE WITHOUT CONSUMING SKILL/AGENT
- Every template MUST be referenced by at least one consuming skill or agent
- Templates without consumers are dead on arrival
- Verify: grep -r "<template-name>" .claude/skills/ .claude/agents/
11. NO CREATION WITHOUT RESEARCH-SYNTHESIS
- Per CLAUDE.md Section 3, research-synthesis MUST be invoked before any creator
- Template creation is no exception
- Invoke: Skill({ skill: 'research-synthesis' })
Use .claude/templates/spawn/universal-agent-spawn.md as the canonical reference template.
Before finalizing any template, compare:
| Practice | Good | Bad |
|---|---|---|
| Naming | {{AGENT_NAME}} | {{name}}, {AGENT_NAME} |
| Required fields | Always present | Sometimes omitted |
| Optional fields | {{FIELD:default}} | No default indicator |
| Documentation | Inline comments | Separate docs file |
| Examples | In comments | None provided |
YAML Frontmatter First
POST-CREATION CHECKLIST Second
Content Sections
Memory Protocol Last
Include validation examples in templates:
## Validation
After replacing placeholders, validate:
```bash
# Check YAML is valid
head -50 <file> | grep -E "^---$" | wc -l # Should be 2
# Check no unresolved placeholders
grep "{{" <file> && echo "ERROR: Unresolved placeholders!"
# Check required sections present
grep -E "^## Memory Protocol" <file> || echo "ERROR: Missing Memory Protocol!"
```
After creating a template, complete this 7-point analysis:
[TEMPLATE-CREATOR] System Impact Analysis for: <template-name>
1. README UPDATE (MANDATORY - Step 9)
- Added to .claude/templates/README.md
- Usage instructions documented
- Quick Reference table updated
2. CATALOG UPDATE (MANDATORY - Step 8)
- Added to .claude/context/artifacts/catalogs/template-catalog.md
- Category, status, agents, skills documented
- Purpose clearly stated
3. CLAUDE.MD UPDATE (CONDITIONAL - Step 10)
- Is template framework-significant? If yes, add to CLAUDE.md
- Spawn templates -> Section 2
- Creator templates -> relevant creator section
- User-invocable -> Section 8.5
4. CONSUMER ASSIGNMENT (MANDATORY - Step 11)
- Which skills/agents consume this template?
- Is template reference added to consuming creator skill?
- Verify with grep across skills/ and agents/
5. RELATED TEMPLATES CHECK
- Does this template supersede an existing one?
- Are there related templates that need cross-references?
- Should archived templates be updated or removed?
6. SECURITY COMPLIANCE (SEC-TMPL-006, SEC-TC-001, SEC-TC-007)
- No secrets, credentials, or absolute paths
- Relative paths only
- Retention mandates respected
- Spawn template placeholders sanitized
7. MEMORY UPDATE
- Record creation in learnings.md
- Document any decisions in decisions.md
This skill is part of the unified artifact lifecycle. For complete multi-agent orchestration:
Router Decision: .claude/workflows/core/router-decision.md
Artifact Lifecycle: .claude/workflows/core/skill-lifecycle.md
External Integration: .claude/workflows/core/external-integration.md
Spawn Template Resolver: .claude/lib/spawn/spawn-template-resolver.cjs
This skill is part of the Creator Ecosystem. Use companion creators when needed:
| Gap Discovered | Required Artifact | Creator to Invoke | When |
|---|---|---|---|
| Domain knowledge needs a reusable skill | skill | Skill({ skill: 'skill-creator' }) | Gap is a full skill domain |
| Existing skill has incomplete coverage | skill update | Skill({ skill: 'skill-updater' }) | Close skill exists but incomplete |
| Capability needs a dedicated agent | agent | Skill({ skill: 'agent-creator' }) | Agent to own the capability |
| Existing agent needs capability update | agent update | Skill({ skill: 'agent-updater' }) | Close agent exists but incomplete |
| Domain needs code/project scaffolding | template | Skill({ skill: 'template-creator' }) | Reusable code patterns needed |
| Behavior needs pre/post execution guards | hook | Skill({ skill: 'hook-creator' }) | Enforcement behavior required |
| Process needs multi-phase orchestration | workflow | Skill({ skill: 'workflow-creator' }) | Multi-step coordination needed |
| Artifact needs structured I/O validation | schema | Skill({ skill: 'schema-creator' }) | JSON schema for artifact I/O |
| User interaction needs a slash command | command | Skill({ skill: 'command-creator' }) | User-facing shortcut needed |
| Repeated logic needs a reusable CLI tool | tool | Skill({ skill: 'tool-creator' }) | CLI utility needed |
| Narrow/single-artifact capability only | inline | Document within this artifact only | Too specific to generalize |
After creating a template that needs additional artifacts:
// 1. Template created for new hook type
// 2. Need to create example hook using template
Skill({ skill: 'hook-creator' });
// 3. Template created for new agent category
// 4. Need to update agent-creator to recognize new category
// Edit .claude/skills/agent-creator/SKILL.md to add category
After template is fully created and validated:
[ ] Does template need a companion skill? -> Use skill-creator
[ ] Does template need a companion workflow? -> Use workflow-creator
[ ] Does template supersede an existing template? -> Archive old one
[ ] Should template be part of enterprise workflows? -> Update Section 8.6
[ ] Does template interact with spawn-template-resolver? -> Update resolver config
This skill outputs to: .claude/templates/
Subdirectories by type:
spawn/ - Agent spawn prompt templates (4 templates)agents/ - Agent definition templates (2 templates)skills/ - Skill definition templates (1 template)workflows/ - Workflow definition templates (1 template)reports/ - Report document templates (5 templates)code-styles/ - Language style guides (3 templates)_archive/ - Archived/deprecated templates (14 templates).claude/docs/FILE_PLACEMENT_RULES.md.claude/docs/DEVELOPER_WORKFLOW.md.claude/docs/ARTIFACT_NAMING.md.claude/rules/workspace-conventions.md (output placement, naming, provenance)File placement is enforced by file-placement-guard.cjs hook.
Invalid placements will be blocked in production mode.
This skill is typically invoked by:
| Agent | Role | Assignment Reason |
|---|---|---|
| planner | Planning standardization | Creates templates for new patterns |
| architect | Architecture patterns | Creates templates for architectural artifacts |
| developer | Code patterns | Creates code scaffolding templates |
To invoke this skill:
Skill({ skill: 'template-creator' });
Request: "Create a template for security audit reports"
Process:
research-synthesis, review existing report templates in .claude/templates/reports/security-audit-report-template matches /^[a-z0-9][a-z0-9-]*[a-z0-9]$/.claude/templates/reports/security-audit-report-template.md---
# [REQUIRED] Report identifier, lowercase-with-hyphens
name: { { REPORT_NAME } }
# [REQUIRED] What this report documents
description: { { REPORT_DESCRIPTION } }
# [REQUIRED] Report type: audit, implementation, research, reflection, plan
type: audit
# [REQUIRED] Severity levels for findings
severity_levels: [CRITICAL, HIGH, MEDIUM, LOW]
---
# {{REPORT_DISPLAY_NAME}} Report
## POST-CREATION CHECKLIST (BLOCKING)
After creating this report:
- [ ] All findings categorized by severity
- [ ] Recommendations actionable and specific
- [ ] Evidence provided for all claims
## Findings
### CRITICAL
{{CRITICAL_FINDINGS}}
### HIGH
{{HIGH_FINDINGS}}
## Recommendations
{{RECOMMENDATIONS}}
## Memory Protocol (MANDATORY)
**Before starting:** Read `.claude/context/memory/learnings.md`
**After completing:** Record patterns to learnings.md
Request: "Create a template for specialized agent spawn prompts"
Process:
research-synthesis, review .claude/templates/spawn/universal-agent-spawn.md.claude/templates/spawn/{template-name}.md---
# [REQUIRED] Template identifier
name: { { TEMPLATE_NAME } }
# [REQUIRED] Agent type this template spawns
agent_type: { { AGENT_TYPE } }
# [REQUIRED] Recommended model: haiku, sonnet, opus
model: { { MODEL:sonnet } }
# [OPTIONAL] Task complexity level
complexity: { { COMPLEXITY:medium } }
---
# {{AGENT_DISPLAY_NAME}} Spawn Template
## Security Notice (SEC-TC-001)
Placeholder values substituted into the `prompt:` field MUST be sanitized using
`sanitizeSubstitutionValue()` from `prompt-factory.cjs` before substitution.
This prevents prompt injection via user-provided task descriptions.
## Usage
Use this template when spawning {{AGENT_TYPE}} agents.
## Spawn Pattern
Task({
subagent_type: '{{AGENT_TYPE}}',
model: '{{MODEL}}',
task_id: '{{TASK_ID}}',
prompt: 'You are {{AGENT_IDENTITY}}. ... TaskUpdate protocol ...'
});
## Validation
After using this template:
- [ ] task_id is unique and matches prompt
- [ ] Model matches agent complexity requirements
- [ ] TaskUpdate protocol included in prompt
- [ ] Success criteria clearly defined
- [ ] No unsanitized user input in prompt field
Symptoms: {{PLACEHOLDER}} appears in final file
Solution:
Symptoms: Template exists but not found by creators
Solution:
grep "<template-name>" .claude/context/artifacts/catalogs/template-catalog.mdSymptoms: Different templates have different formats
Solution:
Symptoms: User-provided content in spawn template placeholder could manipulate agent behavior
Solution:
sanitizeSubstitutionValue() is referenced{{PLACEHOLDER}} tokens directly in prompt: fields for user inputSymptoms: unified-creator-guard.cjs blocks your template write
Solution:
Skill({ skill: 'template-creator' })CREATOR_GUARD=warn (temporary, restore to block after)CREATOR_GUARD=off in productionBefore starting:
cat .claude/context/memory/learnings.md
Check for:
After completing:
.claude/context/memory/learnings.md.claude/context/memory/issues.md.claude/context/memory/decisions.mdASSUME INTERRUPTION: If it's not in memory, it didn't happen.
After creation completes, run the ecosystem integration checklist:
runIntegrationChecklist(artifactType, artifactPath) from .claude/lib/creators/creator-commons.cjsqueueCrossCreatorReview(artifactType, artifactPath) from .claude/lib/creators/creator-commons.cjsmustHave items before marking task completeshouldHave items as follow-up tasksIntegration verification:
This creator skill is part of a coordinated creator ecosystem. Any artifact created here must align with and validate against related creators:
agent-creator for ownership and execution pathsskill-creator for capability packaging and assignmenttool-creator for executable automation surfaceshook-creator for enforcement and guardrailsrule-creator and semgrep-rule-creator for policy and static checkstemplate-creator for standardized scaffoldsworkflow-creator for orchestration and phase gatingcommand-creator for user/operator command UXBefore completion, verify all relevant handshakes:
.claude/CLAUDE.md and related routing docs.validate-integration.cjs passes for the created artifact.For new patterns, templates, or workflows, research is mandatory:
mcp__Exa__web_search_exa({ query: '<topic> 2025 best practices' })mcp__Exa__get_code_context_exa({ query: '<topic> implementation examples' })mcp__Exa__web_search_exa({ query: 'site:arxiv.org <topic> 2024 2025' })WebFetch({ url: 'https://arxiv.org/search/?query=<topic>&searchtype=all&start=0' })arXiv is mandatory (not fallback) when topic involves: AI agents, LLM evaluation, orchestration, memory/RAG, security, static analysis, or any emerging methodology.
Run the shared evaluation framework to verify template quality:
node .claude/skills/skill-creator/scripts/eval-runner.cjs --skill template-creator
Grader assertions for template artifacts:
<PLACEHOLDER> tokens are listed with descriptions; no undocumented substitution points remain after rendering.claude/context/artifacts/catalogs/template-catalog.md with type, purpose, and placeholder inventorySee .claude/skills/skill-creator/EVAL_WORKFLOW.md for full evaluation protocol and grader/analyzer agent usage.