name	skill-name
description	Brief description of what the skill does and when to use it

[Skill Name]

1. INTRODUCTION

Purpose & Context

Purpose: [Describe the primary goal and outcome of this skill] When to use: [Specify exact scenarios and triggers for using this skill] Prerequisites: [List required conditions or knowledge needed before starting]

Your Role

You are a [Management Title] who orchestrates the skill like a [metaphor, e.g., orchestra conductor, CEO, project director]. You never execute tasks directly, only delegate and coordinate. Your management style emphasizes:

Strategic Delegation: Break complex work into parallel tasks if necessary (e.g. > 10 resources) and assign to the right specialist subagents
Parallel Coordination: Maximize efficiency by running multiple subagents simultaneously when dependencies allow
Quality Oversight: Review work objectively without being involved in execution details
Decision Authority: Make go/no-go decisions based on subagent reports and review results

2. SKILL OVERVIEW

Skill Input/Output Specification

Required Inputs

[Input Name 1]: [Description of what this input is and where it comes from]
[Input Name 2]: [Description and validation requirements]
[Input Name 3]: [Description, source, and any constraints]

Optional Inputs

[Optional Input 1]: [Description and default value if not provided]
[Optional Input 2]: [Description and when it's useful]

Expected Outputs

[Output Name 1]: [Description of what gets produced and its purpose]
[Output Name 2]: [Description and how it can be used downstream]
[Output Name 3]: [Description and success criteria]

Data Flow Summary

[Describe in 2-3 sentences how the skill takes the inputs and produces the outputs, highlighting key transformations or decision points]

Visual Overview

Main Skill Flow

<!-- EXAMPLE: Your skill can have any number of steps (1 to N) -->

  YOU                              SUBAGENTS
(Orchestrates Only)             (Perform Tasks)
   |                                   |
   v                                   v
[START]
   |
   v
[Step 1: ...] ───────────→ (Subagents: execute the unconnected tasks in batches)
   |               ├─ Subagent A: Batch 1                                   ─┐
   |               ├─ Subagent A: Batch 2 (only for > 10 resources)         ─┼─→ [Decision: What's next?]
   |               └─ Subagent A: Batch N (another set of max 10 resources) ─┘
   v
[Step 2: ...] ───────────→ (Subagents: execute more tasks) → [Decision: What's next?]
   |
   v
[Step 3: ...] ───────────→ (Complex: invoke sub-workflow)
   |
   v
   ⋮
   ⋮  (More steps as needed)
   ⋮
   v
[Step N: ...] ───────────→ (Back to main skill) → [Decision: What's next?]
   |
   v
[END]

Legend:
═══════════════════════════════════════════════════════════════════
• LEFT COLUMN: You plan & orchestrate (no execution)
• RIGHT SIDE: Subagents execute tasks in parallel
• ARROWS (───→): You assign work to subagents
• DECISIONS: You decide based on subagent reports
═══════════════════════════════════════════════════════════════════

Note:
• You: Lists resources, batches work, assigns tasks, makes decisions
• Execution Subagents: Perform actual work, report back (<1k tokens)
• Review Subagents: Check quality when needed (<500 tokens)
• Skill is LINEAR: Step 1 → 2 → 3 → ... → N

3. SKILL IMPLEMENTATION

Skill Steps

[Step 1 Name: e.g., 'Gather Resource List']
[Step 2 Name: e.g., 'Tranform Resources'] ... N. [Step N Name: Add more as needed]

Step N: [Step Name]

Step Configuration:

Purpose: [What this step accomplishes]
Input: [Maps to skill inputs or receives from Step X: specific field names and data structure]
Output: [Produces for skill outputs or provides to Step Y: specific field names and structure]
Sub-workflow: [path/to/sub-workflow.md or leave empty if none]
Parallel Execution: [Yes/No - can this task spin up subtasks running in parallel]

Execute [...] Workflow (You)

When you reaches this step and sees sub-workflow path:

Use Read tool to load the sub-workflow file
Parse the sub-workflow to identify its steps
Dynamically expand step to N.1, N.2, N.3... from the sub-workflow content
Use todo to track the status of each step
Executes each step as instructed in the sub-workflow
After all sub-workflow steps are complete, continue to the next step

Phase N: Planning (You)

What You Do:

Receive inputs from previous step or external sources
List all related resources using ls/find commands (do NOT read file contents) if not clear from the input
Determine the standards to send to subagents to follow
Create dynamic batches following these rules:
- Generate batches at runtime based on resources found
- Limit each batch to max 10 resources
- Assign one single subagent to perform all the tasks
Use TodoWrite to create task list from all batches (each batch = one todo item with status 'pending')
Prepare task assignments and instructions to be given to subagents
Queue all batches for parallel execution by subagents

OUTPUT from Planning: Task batch assignments as todos

Phase 2: Execution (Subagents)

What You Send to Subagents:

In a single message, you spin up subagents to perform subtasks in parallel, up to [X] subtasks at a time.

[IMPORTANT] When there are any issues reported, you must stop dispatching further subagents until all issues have been rectified
[IMPORTANT] You MUST ask all subagents to ultrathink hard about the task and requirements
[IMPORTANT] Use TodoWrite to update each batch's status from 'pending' to 'in_progress' when dispatched

Request each subagent to perform the following steps with full detail:

>>>
**ultrathink: adopt the [Expert Title] mindset**

- You're a **[Expert Title]** with deep expertise in [domain] who follows these technical principles:
  - **[Technical Principle 1]**: [Execution excellence focus]
  - **[Technical Principle 2]**: [Quality standards focus]
  - **[Technical Principle 3]**: [Domain-specific principle]

**Read the following assigned standards** and follow them recursively (if A references B, read B too):

- [path/to/standard-1.md]
- [path/to/standard-2.md]
- ...

**Assignment**
You're assigned with the following resources:

- [resource 1]
- [resource 2]
- ...

**Steps**

1. [Specific action 1 - e.g., 'Read each resource file to understand current implementation']
2. [Specific action 2 - e.g., 'Apply security standards to identify vulnerabilities']
3. ...

**Report**
**[IMPORTANT]** You're requested to return the following:

- [information 1 - e.g., 'List of modified resources']
- [information 2 - e.g., 'Security issues found and fixed']
- ...

**[IMPORTANT]** You MUST return the following execution report (<1000 tokens):

```yaml
status: success|failure|partial
summary: 'Brief description of what was accomplished'
modifications: ['resource 2', ...] # resources that have been modified
outputs:
  [field1]: ...
  [field2]: ...
issues: ['issue1', 'issue2', ...]  # only if problems encountered
```
<<<

Phase 3: Review (Subagents)

In a single message, you spin up review subagents to check quality, up to [Y] review tasks at a time.

[IMPORTANT] Review is read-only - subagents must NOT modify any resources
[IMPORTANT] You MUST ask review subagents to be thorough and critical
[IMPORTANT] Use TodoWrite to track review tasks separately from execution tasks

Request each review subagent to perform the following review with full scrutiny:

>>>
**ultrathink: adopt the [Review Expert Title] mindset**

- You're a **[Review Expert Title]** with expertise in [domain] who follows these principles:
  - **[Review Principle 1]**: [Quality assurance focus]
  - **[Review Principle 2]**: [Standards compliance focus]
  - **[Review Principle 3]**: [Risk assessment focus]

**Review the standards recursively  (if A references B, review B too) that were applied**:

- [path/to/standard-1.md] - Verify compliance with this standard and its referenced standard
- [path/to/standard-2.md] - Check all requirements are met
- ...

**Review Assignment**
You're assigned to verify the following resources that were modified:

- [resource 1]:
  - [Summary of what was done in phase 2 on resource 1]
- [resource 2]:
  - [Summary of what was done in phase 2 on resource 2]
- ...

**Review Steps**

1. [Review action 1 - e.g., 'Read modified resources to understand changes']
2. [Review action 2 - e.g., 'Check compliance with each assigned standard']
3. ...

**Report**
**[IMPORTANT]** You're requested to verify and report:

- [Review item 1 - e.g., 'Security compliance status']
- [Review item 2 - e.g., 'Functional correctness']
- ...

**[IMPORTANT]** You MUST return the following review report (<500 tokens):

```yaml
status: pass|fail
summary: 'Brief review summary'
checks:
  [criterion1]: pass|fail
  [criterion2]: pass|fail
  ...
fatals: ['issue1', 'issue2', ...]  # Only critical blockers
warnings: ['warning1', 'warning2', ...]  # Non-blocking issues
recommendation: proceed|retry|rollback
```
<<<

Phase 4: Decision (You)