template-creator

Original：🇺🇸 English

Translated

3 scriptsChecked / no sensitive code detected

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.

5installs

Sourceoimiragieo/agent-studio

Added on2026-02-21

NPX Install

npx skill4agent add oimiragieo/agent-studio template-creator

SKILL.md Content

View Translation Comparison →

Mode: Cognitive/Prompt-Driven -- No standalone utility script; use via agent context.

Template Creator Skill

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" })                       |
|                                                               |
+==============================================================+

ROUTER UPDATE REQUIRED (CRITICAL - DO NOT SKIP)

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.md Section 2 or 8.5 if template is framework-significant or user-invocable
Consuming creator skill if template standardizes an artifact type
```
.claude/context/memory/learnings.md
```
- Record creation

Verification:

bash

grep "<template-name>" .claude/templates/README.md || echo "ERROR: README NOT UPDATED!"
grep "<template-name>" .claude/context/artifacts/catalogs/template-catalog.md || echo "ERROR: CATALOG NOT UPDATED!"

WHY: Templates not in the catalog are invisible to other creators and will never be used.

Overview

Templates ensure consistency across the multi-agent framework. This skill creates templates for:

Agent definitions - Standardized agent structures
Skill definitions - Reusable capability patterns
Workflow definitions - Multi-agent orchestration patterns
Spawn prompts - Agent spawn prompt templates consumed by
```
spawn-template-resolver.cjs
```
Reports - Report document templates
Code style guides - Language-specific coding standards
General documents - ADRs, specs, checklists, and other framework documents

Core principle: Templates are the DNA of the system. Consistent templates produce consistent, predictable agents and skills.

When to Use

Always:

Creating a new type of artifact that will be replicated
Standardizing an existing pattern across the codebase
Adding a new template category
Improving existing templates with better patterns

Exceptions:

One-off files that will never be replicated
Temporary/throwaway code

Template Types

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

Template Security Compliance

Critical Security Requirements:

No Secrets (SEC-TC-007): Templates MUST NOT include secrets, credentials, tokens, or API keys
Path Safety: All template references MUST use relative paths (
```
.claude/templates/...
```
), never absolute paths
No Sensitive Metadata: Templates MUST NOT expose internal system paths or user directories
No Windows Reserved Names: Template names MUST NOT use
```
nul
```
,
```
con
```
,
```
prn
```
,
```
aux
```
,
```
com1
```
-
```
com9
```
,
```
lpt1
```
-
```
lpt9
```
Retention Mandates (SEC-TMPL-006): Templates flagged by SEC-TMPL-006 MUST remain at designated locations
Spawn Template Placeholder Safety (SEC-TC-001): Spawn templates with
```
{{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.
No Eval/Exec: Templates MUST NOT contain
```
eval()
```
,
```
exec()
```
,
```
Function()
```
, or other code execution patterns

Enforcement:

unified-creator-guard.cjs

hook blocks direct template writes (default: block mode).

The Iron Law

NO TEMPLATE WITHOUT PLACEHOLDER DOCUMENTATION

Every

{{PLACEHOLDER}}

must have a corresponding comment explaining:

What value should replace it
Valid options/formats
Example value

No exceptions:

Every placeholder is documented
Every required field is marked
Every optional field has a default

Workflow Steps

Step 0: Research-Synthesis (MANDATORY - BLOCKING)

Per CLAUDE.md Section 3 requirement, invoke

research-synthesis

BEFORE template creation:

javascript

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
If creating for a new domain, research best-practice template structures via WebSearch

BLOCKING: Template creation CANNOT proceed without research-synthesis invocation.

Step 0.5: Companion Check

Before proceeding with creation, run the ecosystem companion check:

Use

companion-check.cjs

from

.claude/lib/creators/companion-check.cjs

Call

checkCompanions("template", "{template-name}")

to identify companion artifacts

Review the companion checklist — note which required/recommended companions are missing
Plan to create or verify missing companions after this artifact is complete
Include companion findings in post-creation integration notes

This step is informational (does not block creation) but ensures the full artifact ecosystem is considered.

Step 1: Gather Requirements

Analyze the request:

Template Type: Which category (spawn, agent, skill, workflow, report, code-style, document)?
Purpose: What will this template be used for?
Required Fields: What fields are mandatory?
Optional Fields: What fields are optional with defaults?
Validation Rules: What constraints apply?
Consumers: Which creators/agents will use this template?

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

Step 2: Template Type Classification

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

Step 3: Name Validation (SEC-TC-003)

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:

Lowercase letters, digits, and hyphens only
Must start and end with a letter or digit (not a hyphen)
No path separators (
```
/
```
,
```
\
```
), no
```
..
```
, no special characters
No Windows reserved names (
```
nul
```
,
```
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)

Step 4: Determine Output Path

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:

Path MUST start with
```
.claude/templates/
```
Path MUST NOT contain
```
..
```
segments after normalization
Path MUST end with
```
.md
```

Step 5: Content Design

Design the template content following these standards:

Placeholder Format Standard

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}}`

Template Structure

markdown

---
# 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 -->

Security Checklist for Spawn Templates (SEC-TC-001)

If creating a SPAWN template, you MUST also verify:

No
```
{{PLACEHOLDER}}
```
tokens inside
```
prompt:
```
fields that accept unsanitized user input

Reference to

sanitizeSubstitutionValue()

from

prompt-factory.cjs

included in documentation

TaskUpdate protocol is present in the spawn prompt body
```
allowed_tools
```
array does not grant
```
Task
```
tool to non-orchestrator agents
No prompt override patterns (
```
IGNORE PREVIOUS
```
,
```
SYSTEM:
```
, etc.) in template body
Template size under 50KB

Documentation Comments

Add inline documentation for each placeholder:

markdown

---
# [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 } }
---

Step 6: Write Template File

Write to the validated output path determined in Step 4:

bash

Write: .claude/templates/<category>/<template-name>.md

Step 7: Validate Template Structure (BLOCKING)

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:

bash

# 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.

Step 8: Update Template Catalog (MANDATORY - BLOCKING)

Update the template catalog to ensure the new template is discoverable.

Read current catalog:

bash

cat .claude/context/artifacts/catalogs/template-catalog.md

Determine template category based on type:
- Spawn (
```
spawn/
```
  ), Creator (
```
agents/
```
  ,
```
skills/
```
  ,
```
workflows/
```
  ), Document (root), Report (
```
reports/
```
  ), Code Style (
```
code-styles/
```
  )

Add template entry in correct category section:

markdown

### <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:

bash

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.

Step 9: Update Templates README (MANDATORY - BLOCKING)

After updating the catalog, update

.claude/templates/README.md

Add to appropriate section (or create new section)
Document usage instructions
Add to Quick Reference table

Entry format:

markdown

### {{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:

bash

grep "<template-name>" .claude/templates/README.md || echo "ERROR: README NOT UPDATED - BLOCKING!"

BLOCKING: README must contain the template entry.

Step 10: Update CLAUDE.md (CONDITIONAL - BLOCKING)

If the template is framework-significant or user-invocable:

Check if template needs CLAUDE.md entry:
- Is it a new spawn template? -> Update Section 2 (Spawn Templates)
- Is it a new creator template? -> Update relevant creator section
- Is it a user-invocable template? -> Update Section 8.5

If YES, add entry:

markdown

**{Template Name}:** `.claude/templates/{category}/{name}.md`

Verify:

bash

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.

Step 11: Assign Consumer Agents

Templates exist to be consumed by creators and agents. After creation:

Identify consumers based on template type:
- Agent templates -> agent-creator skill should reference
- Skill templates -> skill-creator skill should reference
- Workflow templates -> workflow-creator skill should reference
- Report templates -> relevant agents (qa, developer, etc.)
- Spawn templates -> router documentation, spawn-template-resolver
- Code style templates -> developer, code-reviewer

Update consuming skill/agent to reference the template:

markdown

**Available Templates:**

- See `.claude/templates/<category>/<template-name>.md` for standardized <type> template

Verify at least one consumer references the template:

bash

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.

Step 12: Integration Verification (BLOCKING - DO NOT SKIP)

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:

bash

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):
- Read the error output for specific failures
- Fix each failure:
  - Missing README entry -> Add to
    .claude/templates/README.md
  - Missing catalog entry -> Add to
    template-catalog.md
  - Missing memory update -> Update
    learnings.md
- Re-run validation until exit code is 0
Only 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

Step 13: Completion Checklist (BLOCKING)

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.

Architecture Compliance

File Placement (ADR-076)

Templates:
```
.claude/templates/{category}/
```
(spawn, agents, skills, workflows, reports, code-styles)
Archived templates:
```
.claude/templates/_archive/
```

Template catalog:

.claude/context/artifacts/catalogs/template-catalog.md

Tests:
```
tests/
```
(NOT in
```
.claude/
```
)

Documentation References (CLAUDE.md v2.2.1)

Reference files use @notation: @TOOL_REFERENCE.md, @SKILL_CATALOG_TABLE.md
Located in:
```
.claude/docs/@*.md
```
See: CLAUDE.md Section 2 (Spawn Templates)

Shell Security (ADR-077)

Spawn templates MUST include:
```
cd "$PROJECT_ROOT" || exit 1
```
for background tasks
Environment variables control validators (block/warn/off mode)
See:
```
.claude/docs/SHELL-SECURITY-GUIDE.md
```
Apply to: all spawn templates, background task templates

Security Compliance (ADR-085, ADR-086, SEC-TMPL-006)

Templates MUST NOT include hardcoded secrets, credentials, or API keys
Templates MUST use relative paths (
```
.claude/templates/...
```
), never absolute paths
Templates MUST NOT expose internal system paths or user directories
Retention mandates: security-design-checklist.md and error-recovery-template.md must remain at designated locations
Spawn template placeholder sanitization: reference
```
sanitizeSubstitutionValue()
```
in
```
prompt-factory.cjs
```

Recent ADRs

ADR-075: Router Config-Aware Model Selection
ADR-076: File Placement Architecture Redesign
ADR-077: Shell Command Security Architecture
ADR-085: Template System Overhaul (spawn resolver + dead template cleanup)
ADR-086: Template-Creator Overhaul to v2.1 Creator Standard

Iron Laws of Template Creation

These 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' })

Reference Template

Use
.claude/templates/spawn/universal-agent-spawn.md
as the canonical reference template.

Before finalizing any template, compare:

Has clear placeholder documentation
Placeholders are UPPERCASE with underscores
Has usage examples section
Has integration notes
Has POST-CREATION CHECKLIST
Has Memory Protocol

Template Best Practices

Placeholder Standards

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

Structure Standards

YAML Frontmatter First
- All machine-readable metadata
- Comments explaining each field
POST-CREATION CHECKLIST Second
- Blocking steps after using template
- Verification commands
Content Sections
- Follow existing pattern for type
- Include all required sections
Memory Protocol Last
- Standard format across all templates
- Always present

Validation Examples

Include validation examples in templates:

markdown

## 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!"
```

System Impact Analysis (MANDATORY)

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

Workflow Integration

This skill is part of the unified artifact lifecycle. For complete multi-agent orchestration:

Router Decision:

.claude/workflows/core/router-decision.md

How the Router discovers and invokes this skill's artifacts

Artifact Lifecycle:

.claude/workflows/core/skill-lifecycle.md

Discovery, creation, update, deprecation phases
Version management and registry updates
CLAUDE.md integration requirements

External Integration:

.claude/workflows/core/external-integration.md

Safe integration of external artifacts
Security review and validation phases

Spawn Template Resolver:

.claude/lib/spawn/spawn-template-resolver.cjs

Programmatic template selection for spawn operations
Template scoring and fallback logic

Cross-Reference: Creator Ecosystem

This skill is part of the Creator Ecosystem. Use companion creators when needed:

Creator	When to Use	Invocation
agent-creator	Template needs agent integration	`Skill({ skill: 'agent-creator' })`
skill-creator	Template needs skill integration	`Skill({ skill: 'skill-creator' })`
workflow-creator	Template needs workflow patterns	`Skill({ skill: 'workflow-creator' })`
schema-creator	Template needs JSON schemas	`Skill({ skill: 'schema-creator' })`
hook-creator	Template needs hooks	`Skill({ skill: 'hook-creator' })`

Integration Workflow

After creating a template that needs additional artifacts:

javascript

// 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

Post-Creation Checklist for Ecosystem Integration

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

File Placement & Standards

Output Location Rules

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)
Root level - General document templates (8+ templates)
```
_archive/
```
- Archived/deprecated templates (14 templates)

Mandatory References

File Placement: See
```
.claude/docs/FILE_PLACEMENT_RULES.md
```
Developer Workflow: See
```
.claude/docs/DEVELOPER_WORKFLOW.md
```
Artifact Naming: See
```
.claude/docs/ARTIFACT_NAMING.md
```
Workspace Conventions: See
```
.claude/rules/workspace-conventions.md
```
(output placement, naming, provenance)

Enforcement

File placement is enforced by

file-placement-guard.cjs

hook. Invalid placements will be blocked in production mode.

Assigned Agents

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:

javascript

Skill({ skill: 'template-creator' });

Examples

Example 1: Creating a Report Template

Request: "Create a template for security audit reports"

Process:

Research: Invoke
```
research-synthesis
```
, review existing report templates in
```
.claude/templates/reports/
```
Gather: Analyze report type, security focus, audit findings structure

Validate name:

security-audit-report-template

matches

/^[a-z0-9][a-z0-9-]*[a-z0-9]$/

Design: Structure for security audit reports

Create:

.claude/templates/reports/security-audit-report-template.md

markdown

---
# [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

Update catalog: Add to template-catalog.md under Report Templates
Update README: Add to reports section in templates README
Assign consumers: Update security-architect and qa agent references
Update memory: Record in learnings.md

Example 2: Creating a Spawn Template

Request: "Create a template for specialized agent spawn prompts"

Process:

Research: Invoke

research-synthesis

, review

.claude/templates/spawn/universal-agent-spawn.md

Gather: Analyze spawn pattern, specialized vs general-purpose
Validate name:
```
specialized-agent-spawn
```
matches name regex
Design: Structure for specialized spawn prompts with security considerations (SEC-TC-001)

Create:

.claude/templates/spawn/specialized-agent-spawn.md

markdown

---
# [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

Update catalog: Add to template-catalog.md under Spawn Templates
Update README: Add to spawn section in templates README
Update CLAUDE.md: Add to Section 2 (Spawn Templates) if framework-standard
Assign consumers: Update router and spawn-template-resolver references
Update memory: Record in learnings.md

Troubleshooting

Issue: Placeholders Not Rendering

Symptoms:

{{PLACEHOLDER}}

appears in final file

Solution:

Check placeholder format (double braces, UPPER_CASE)
Ensure user replaced all placeholders
Add validation command to catch unreplaced

Issue: Template Not Discoverable

Symptoms: Template exists but not found by creators

Solution:

Verify template-catalog.md is updated (Step 8)
Verify README.md is updated (Step 9)
Check file is in correct directory

Run:

grep "<template-name>" .claude/context/artifacts/catalogs/template-catalog.md

Issue: Inconsistent Template Structure

Symptoms: Different templates have different formats

Solution:

Review existing templates before creating
Use this skill's patterns
Compare against reference template (universal-agent-spawn.md)
Run consistency check across templates

Issue: Spawn Template Injection Risk

Symptoms: User-provided content in spawn template placeholder could manipulate agent behavior

Solution:

Review SEC-TC-001 guidance in this skill
Ensure
```
sanitizeSubstitutionValue()
```
is referenced
Do not place
```
{{PLACEHOLDER}}
```
tokens directly in
```
prompt:
```
fields for user input
Use structured task descriptions that separate user content from system instructions

Issue: Creator Guard Blocking Template Write

Symptoms:

unified-creator-guard.cjs

blocks your template write

Solution:

Ensure you invoked this skill properly:
```
Skill({ skill: 'template-creator' })
```
Check that the creator state is active (3-minute TTL)
If debugging:
```
CREATOR_GUARD=warn
```
(temporary, restore to
```
block
```
after)
Never use
```
CREATOR_GUARD=off
```
in production

Memory Protocol (MANDATORY)

Before starting:

bash

cat .claude/context/memory/learnings.md

Check for:

Previously created templates
Known template patterns
User preferences for template behavior

After completing:

New template pattern ->
```
.claude/context/memory/learnings.md
```
Issue found ->
```
.claude/context/memory/issues.md
```
Decision made ->
```
.claude/context/memory/decisions.md
```

ASSUME INTERRUPTION: If it's not in memory, it didn't happen.

Post-Creation Integration

After creation completes, run the ecosystem integration checklist:

Call

runIntegrationChecklist(artifactType, artifactPath)

from

.claude/lib/creators/creator-commons.cjs

Call

queueCrossCreatorReview(artifactType, artifactPath)

from

.claude/lib/creators/creator-commons.cjs

Review the impact report — address all
```
mustHave
```
items before marking task complete
Log any
```
shouldHave
```
items as follow-up tasks

Integration verification:

Template added to template-catalog.md
Template README exists at template location
Template assigned to consuming skill(s)
Template examples provided

Ecosystem Alignment Contract (MANDATORY)

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 paths
```
skill-creator
```
for capability packaging and assignment
```
tool-creator
```
for executable automation surfaces
```
hook-creator
```
for enforcement and guardrails
```
rule-creator
```
and
```
semgrep-rule-creator
```
for policy and static checks
```
template-creator
```
for standardized scaffolds
```
workflow-creator
```
for orchestration and phase gating
```
command-creator
```
for user/operator command UX

Cross-Creator Handshake (Required)

Before completion, verify all relevant handshakes:

Artifact route exists in
```
.claude/CLAUDE.md
```
and related routing docs.
Discovery/registry entries are updated (catalog/index/registry as applicable).
Companion artifacts are created or explicitly waived with reason.
```
validate-integration.cjs
```
passes for the created artifact.
Skill index is regenerated when skill metadata changes.

Research Gate (Exa First, arXiv Fallback)

For new patterns, templates, or workflows, research is mandatory:

Use Exa first for implementation and ecosystem patterns.
If Exa is insufficient, use
```
WebFetch
```
plus arXiv references.
Record decisions, constraints, and non-goals in artifact references/docs.
Keep updates minimal and avoid overengineering.

Regression-Safe Delivery

Follow strict RED -> GREEN -> REFACTOR for behavior changes.
Run targeted tests for changed modules.
Run lint/format on changed files.
Keep commits scoped by concern (logic/docs/generated artifacts).

template-creator

NPX Install

Tags

SKILL.md Content

Template Creator Skill

ROUTER UPDATE REQUIRED (CRITICAL - DO NOT SKIP)

Overview

When to Use

Template Types

Template Security Compliance

The Iron Law

Workflow Steps

Step 0: Research-Synthesis (MANDATORY - BLOCKING)

Step 0.5: Companion Check

Step 1: Gather Requirements

Step 2: Template Type Classification

Step 3: Name Validation (SEC-TC-003)

Step 4: Determine Output Path

Step 5: Content Design

Placeholder Format Standard

Template Structure

Security Checklist for Spawn Templates (SEC-TC-001)

Documentation Comments

Step 6: Write Template File

Step 7: Validate Template Structure (BLOCKING)

Step 8: Update Template Catalog (MANDATORY - BLOCKING)

Step 9: Update Templates README (MANDATORY - BLOCKING)

Step 10: Update CLAUDE.md (CONDITIONAL - BLOCKING)

Step 11: Assign Consumer Agents

Step 12: Integration Verification (BLOCKING - DO NOT SKIP)

Step 13: Completion Checklist (BLOCKING)

Architecture Compliance

File Placement (ADR-076)

Documentation References (CLAUDE.md v2.2.1)

Shell Security (ADR-077)

Security Compliance (ADR-085, ADR-086, SEC-TMPL-006)

Recent ADRs

Iron Laws of Template Creation

Reference Template

Template Best Practices

Placeholder Standards

Structure Standards

Validation Examples

System Impact Analysis (MANDATORY)

Workflow Integration

Cross-Reference: Creator Ecosystem

Integration Workflow

Post-Creation Checklist for Ecosystem Integration

File Placement & Standards

Output Location Rules

Mandatory References

Enforcement

Assigned Agents

Examples

Example 1: Creating a Report Template

Example 2: Creating a Spawn Template

Troubleshooting

Issue: Placeholders Not Rendering

Issue: Template Not Discoverable

Issue: Inconsistent Template Structure

Issue: Spawn Template Injection Risk

Issue: Creator Guard Blocking Template Write

Memory Protocol (MANDATORY)

Post-Creation Integration

Ecosystem Alignment Contract (MANDATORY)

Cross-Creator Handshake (Required)

Research Gate (Exa First, arXiv Fallback)

Regression-Safe Delivery