Aiwg add-template

Scaffold a new document template inside an existing addon or framework

install

source · Clone the upstream repo

git clone https://github.com/jmagly/aiwg

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/jmagly/aiwg "$T" && mkdir -p ~/.claude/skills && cp -r "$T/.agents/skills/add-template" ~/.claude/skills/jmagly-aiwg-add-template && rm -rf "$T"

manifest: .agents/skills/add-template/SKILL.md

source content

Add Template

Scaffold a new document template inside an existing addon or framework.

Triggers

Alternate expressions and non-obvious activations (primary phrases are matched automatically from the skill description):

"I need a new template" → scaffold template in specified target
"add a document template" → prompt for name, category, and target
"create a template for X documents" → derive name from X, prompt for target
"template for use cases" → name=
```
use-case
```
, prompt for target and category

Trigger Patterns Reference

Pattern	Example	Action
Named add	"add template adr --to sdlc-complete"	Scaffold directly
Category specified	"add template threat-model --to sdlc-complete --category security"	Place in category subdir
Interactive	"add template --interactive --to sdlc-complete"	Guided design mode
Target omitted	"add template risk-register"	Ask which addon or framework

Process

1. Parse Arguments

Extract from

$ARGUMENTS

```
<name>
```
— kebab-case template name (required)
```
--to <target>
```
— addon or framework directory name (required)

--category <category>

— subdirectory within

templates/

(optional; e.g.,

requirements

architecture

security

)

```
--interactive
```
— enable guided design questions

If either

<name>

--to

is missing, ask before proceeding.

2. Validate Target

Confirm the target exists:

# Check addons
ls agentic/code/addons/<target>/templates/

# Check frameworks
ls agentic/code/frameworks/<target>/templates/

3. Determine Category

--category

is not provided and the target has existing category subdirectories, list them and ask. Common categories in sdlc-complete:

Category	Contents
`requirements`	Use cases, user stories, NFRs
`architecture`	SAD, ADRs, C4 diagrams
`security`	Threat models, security gates
`testing`	Test plans, test cases, test reports
`deployment`	Deployment plans, runbooks
`planning`	Phase plans, iteration plans, risk registers
`analysis-design`	Domain models, sequence diagrams

If no category is appropriate, place directly in

templates/

4. Interactive Design (if --interactive)

Ask before generating:

Purpose: What SDLC artifact does this template produce?
Audience: Who fills in this template? (developer, architect, project manager)
Required sections: What sections must every instance include?
Optional sections: What sections depend on the specific project?
Variables: What
```
{{placeholder}}
```
variables should be pre-populated by tooling?
Examples: Should the template include inline examples?

5. Run Scaffolding

aiwg add-template <name> --to <target> [--category <category>]

6. Customize the Generated Template

Templates use Markdown with YAML frontmatter and

{{variable}}

placeholders:

---
template: <name>
version: 1.0.0
category: <category>
description: <one-sentence purpose>
variables:
  - project_name
  - author
  - date
---

# <Template Title>

**Project**: {{project_name}}
**Author**: {{author}}
**Date**: {{date}}
**Version**: 1.0

---

## Purpose

[What this document is for and when to create it]

## Section 1: <Required Section>

[Instructions for completing this section]

> **Guidance**: [What a good answer looks like]

## Section 2: <Required Section>

[Instructions]

## Section 3: <Optional Section> *(if applicable)*

[Instructions]

---

## Review Checklist

Before finalizing this document:

- [ ] All required sections completed
- [ ] Variables replaced with actual values
- [ ] Reviewed by [role]
- [ ] Approved by [role]

7. Register in Templates Manifest

The CLI tool updates the templates manifest. Verify:

{
  "templates": {
    "<category>": ["existing-template", "<name>"]
  }
}

Generated Structure

<target>/templates/<category>/<name>-template.md

Or at root if no category:

<target>/templates/<name>-template.md

Manifest updated:

<target>/manifest.json

(or

templates/manifest.json

if present)

Output Format

Template Created: <name>
────────────────────────
Location: <target>/templates/<category>/<name>-template.md
Category:  <category>

Created:
  ✓ <name>-template.md

Manifest updated: <target>/manifest.json

Next Steps:
  1. Define required sections and guidance text
  2. Add {{variable}} placeholders for automation
  3. Include review checklist
  4. Test: aiwg template-engine apply <name> --to .aiwg/<category>/

Examples

Example 1: Architecture decision record

User: "add template adr --to sdlc-complete --category architecture"

Action:

aiwg add-template adr --to sdlc-complete --category architecture

Result:

agentic/code/frameworks/sdlc-complete/templates/architecture/adr-template.md

scaffolded with standard ADR sections (Context, Decision, Consequences, Alternatives).

Example 2: Security threat model

User: "create a threat model template for sdlc-complete"

Extraction: name=

threat-model

, target=

sdlc-complete

, category=

security

Action:

aiwg add-template threat-model --to sdlc-complete --category security

Example 3: Interactive template design

User: "add template --interactive --to sdlc-complete"

Process: Guided questions establish the artifact type, required sections, variables, and whether examples should be embedded.

References

@$AIWG_ROOT/src/cli/handlers/scaffolding.ts — CLI handler implementation
@$AIWG_ROOT/docs/cli-reference.md — Full CLI reference
@$AIWG_ROOT/agentic/code/frameworks/sdlc-complete/templates/ — Example templates
@$AIWG_ROOT/agentic/code/addons/aiwg-utils/skills/devkit-create-skill/SKILL.md — Related scaffolding pattern