# create-command

> Generate custom commands following established patterns and style guidelines

- Author: Nash Gao
- Repository: nashgao/mqtt-client
- Version: 20260210001543
- Stars: 3
- Forks: 1
- Last Updated: 2026-02-09
- Source: https://github.com/nashgao/mqtt-client
- Web: https://mule.run/skillshub/@@nashgao/mqtt-client~create-command:20260210001543

---

---
allowed-tools: all
description: Generate custom commands following established patterns and style guidelines
---

# ⚡⚡⚡ CRITICAL REQUIREMENT: CREATE PERFECTLY FORMATTED CUSTOM COMMAND! ⚡⚡⚡

**THIS IS NOT A TEMPLATE COPYING TASK - THIS IS A CUSTOM COMMAND GENERATION TASK!**

When you run `/create-command`, you are REQUIRED to:

1. **ANALYZE** the user's command requirements from $ARGUMENTS thoroughly
2. **STUDY** existing command patterns to ensure perfect consistency
3. **GENERATE** a complete custom command following the exact established style
4. **USE MULTIPLE AGENTS** for comprehensive command creation:
   - Spawn one agent to analyze existing command patterns
   - Spawn another to parse and understand user requirements
   - Spawn more agents for different command sections
   - Say: "I'll spawn multiple agents to create this custom command with perfect consistency"
5. **DO NOT STOP** until:
   - ✅ Command follows exact format and style of existing commands
   - ✅ ALL required sections are present and properly formatted
   - ✅ Command is contextually appropriate for the specified purpose
   - ✅ YAML front matter and markdown structure are perfect

**FORBIDDEN BEHAVIORS:**
- ❌ "Close enough to existing style" → NO! Follow the pattern EXACTLY!
- ❌ "Skip some sections to save time" → NO! Include ALL required sections!
- ❌ "Generic template will work" → NO! Create contextually specific content!
- ❌ Inconsistent formatting → NO! Match existing commands precisely!

**MANDATORY WORKFLOW:**
```
1. Requirements analysis → Parse user's command description
2. IMMEDIATELY spawn agents for pattern analysis and generation
3. FOLDER-FIRST DETECTION → Check for existing command families
4. Pattern study → Analyze existing command structure exactly
5. Hierarchical placement → Apply folder-first logic for command location
6. Custom generation → Create command specific to user requirements
7. VERIFY format → Ensure perfect consistency with existing style
```

**YOU ARE NOT DONE UNTIL:**
- Command follows exact format of existing commands
- All required sections are present and properly formatted
- Content is contextually appropriate for the specified purpose
- Command is saved to **templates/skills/** directory (using folder-first logic)
- Hierarchical placement rules applied correctly
- Command invocation pattern updated to match placement

---

🛑 **MANDATORY COMMAND GENERATION PROTOCOL** 🛑
1. Re-read ~/.claude/CLAUDE.md RIGHT NOW
2. Check current TODO.md status
3. **SCAN templates/skills/ directory** for existing command families
4. **APPLY folder-first detection logic** to determine command placement
5. Analyze existing commands for pattern consistency

Execute comprehensive custom command generation with ZERO tolerance for format deviations.

**FORBIDDEN SHORTCUT PATTERNS:**
- "The basic structure is similar" → NO, follow the EXACT pattern
- "Some sections don't apply" → NO, adapt sections to fit the purpose
- "Users will understand" → NO, maintain strict formatting consistency
- "Close enough formatting" → NO, precision is required
- "Generic commands work fine" → NO, create specific, contextual commands

You are creating a custom command for: $ARGUMENTS

Let me ultrathink about generating a perfectly formatted custom command that follows all established patterns.

🚨 **REMEMBER: Command consistency is crucial for user experience!** 🚨

**Comprehensive Custom Command Generation Protocol:**

**Step 0: User Requirements Analysis**
Parse the command description from $ARGUMENTS to identify:
- Primary command purpose and objective
- Target workflow or process to be automated
- Success criteria and completion requirements
- Required tools and capabilities
- Appropriate intensity level (critical, important, standard)

**Step 1: Pattern Analysis and Template Extraction**
Study existing commands to extract exact patterns:
- YAML front matter format and required fields
- Emoji usage patterns and intensity indicators
- Section headers and formatting conventions
- Workflow structure and mandatory elements
- Agent spawning patterns and examples
- Checklist formats and verification criteria

**Step 2: Multi-Agent Command Generation Strategy**
Deploy specialized generation agents for parallel development:

```
"I need to create a custom [COMMAND_TYPE] command following exact patterns. I'll spawn generation agents:
- Agent 1: Analyze existing command patterns and extract templates
- Agent 2: Parse user requirements and map to command structure
- Agent 3: Generate YAML front matter and core sections
- Agent 4: Create workflow steps and agent spawning strategies
- Agent 5: Develop checklists and verification criteria
- Agent 6: Format final command and validate consistency
Let me generate this custom command with perfect pattern compliance..."
```

**Command Structure Requirements:**

**YAML Front Matter (MANDATORY):**
```yaml
---
allowed-tools: all
description: [Specific, actionable description of command purpose]
---
```

**Header Section Pattern:**
- Emoji indicators (intensity: 🚨🚨🚨 critical, 🔍🔍🔍 analysis, ⚡⚡⚡ action)
- Bold all-caps requirement statement
- "THIS IS NOT A [X] - THIS IS A [Y] TASK!" pattern

**Core Requirements Section:**
- Numbered list (1-5 items) of specific actions required
- "USE MULTIPLE AGENTS" subsection with examples
- "DO NOT STOP" until criteria with ✅ checkmarks

**Forbidden Behaviors Section:**
- ❌ pattern with specific examples relevant to command purpose
- Common mistakes and anti-patterns to avoid

**Mandatory Workflow:**
- Code block with numbered steps
- Clear progression from start to completion

**Completion Criteria:**
- "YOU ARE NOT DONE UNTIL:" section
- Specific, measurable completion requirements

**Main Protocol Section:**
- Detailed step-by-step execution protocol
- Step 0, 1, 2, etc. with specific requirements
- Checklists with [ ] checkbox format
- Quality requirements and standards

**Agent Spawning Strategy:**
- Specific examples of agent deployment
- Clear division of responsibilities
- Parallel execution patterns

**Anti-patterns Section:**
- ❌ forbidden behaviors specific to command purpose
- Clear guidance on what NOT to do

**Final Sections:**
- Verification criteria for completion
- Final commitment with "I will" and "I will NOT" lists
- Remember statement
- Execution statement

**Command Types and Adaptation Patterns:**

**Analysis Commands** (🔍🔍🔍):
- Focus on comprehensive investigation
- Multiple analysis agents for different aspects
- Evidence gathering and documentation
- Systematic evaluation protocols

**Implementation Commands** (⚡⚡⚡):
- Emphasis on execution and delivery
- Parallel implementation agents
- Quality gates and checkpoints
- Production-ready requirements

**Verification Commands** (🚨🚨🚨):
- Zero-tolerance for issues
- Comprehensive testing and validation
- Error elimination requirements
- Quality assurance protocols

**Step 3: Content Generation and Contextualization**
Generate command content specifically tailored to user requirements:
- Adapt emoji intensity to command criticality
- Create contextually relevant forbidden behaviors
- Generate appropriate workflow steps
- Develop domain-specific checklists
- Create relevant agent spawning examples

**Content Quality Standards:**
- [ ] All sections present and properly formatted
- [ ] Content is specific to command purpose (not generic)
- [ ] Examples are contextually relevant and actionable
- [ ] Formatting matches existing commands exactly
- [ ] YAML front matter is valid and complete
- [ ] Markdown structure follows established patterns

**Step 4: Format Validation and Consistency Check**
Verify the generated command against existing patterns:
- [ ] YAML front matter format is identical
- [ ] Section headers follow exact capitalization and formatting
- [ ] Emoji patterns match intensity and purpose
- [ ] Workflow structure follows established format
- [ ] Agent spawning examples follow established patterns
- [ ] Checklist formatting is consistent
- [ ] Final sections follow exact order and format

**Step 5: Intelligent Command Placement Strategy**


**MANDATORY FOLDER-FIRST DETECTION:**
Before creating any command, you MUST:
1. **Analyze command name** for existing folder matches
2. **Check templates/skills/ directory** for similar folder structures
3. **Apply hierarchical placement rules** based on existing patterns
4. **Ensure consistent naming conventions** across command families

**Folder Detection Algorithm:**
```
Command Name Analysis:
├── Extract base name (e.g., "milestone-status" → "milestone")
├── Check if folder exists: templates/skills/[base-name]/
├── If folder exists: Create as sub-command → [base-name]/[sub-name].md
├── If no folder: Create as standalone → [command-name].md
└── Apply naming consistency rules
```

**Hierarchical Placement Rules:**
- **Existing folder match**: `milestone-status` → `milestone/status.md`
- **Related command family**: `git-branch` → `git/branch.md`
- **Standalone command**: `architect` → `architect.md`
- **Sub-command hint**: User mentions "sub-command" → force hierarchical placement

**File Generation and Placement:**
- Generate appropriate filename based on placement strategy
- Save to **templates/skills/** directory (NOT .claude/skills/)
- Apply folder-first logic before file creation
- Ensure file permissions are correct
- Validate file was created successfully in correct location

**Custom Command Quality Checklist:**
- [ ] Follows exact YAML front matter format
- [ ] Header section uses appropriate emoji intensity
- [ ] All mandatory sections are present
- [ ] Content is specific to user requirements (not generic)
- [ ] Workflow steps are logical and actionable
- [ ] Agent spawning strategy is well-defined
- [ ] Forbidden behaviors are contextually relevant
- [ ] Checklists use proper checkbox formatting
- [ ] Final commitment sections follow exact pattern
- [ ] File is saved to correct location

**Command Generation Anti-patterns (FORBIDDEN):**
- ❌ "Generic template with minor changes" → NO, create specific content
- ❌ "Skip sections that don't seem relevant" → NO, adapt all sections
- ❌ "Close enough formatting" → NO, match exactly
- ❌ "Users will figure it out" → NO, provide clear, specific guidance
- ❌ "Basic command structure" → NO, comprehensive command required
- ❌ "Copy existing command" → NO, generate custom content

**Template Adaptation Guidelines:**
- Maintain exact structure while adapting content
- Use domain-specific language and examples
- Ensure forbidden behaviors are contextually relevant
- Create appropriate success criteria for the purpose
- Generate realistic agent spawning scenarios

**Final Command Generation Verification:**
The custom command is complete when:
✓ All sections follow exact format of existing commands
✓ Content is specifically tailored to user requirements
✓ YAML front matter is valid and complete
✓ Workflow steps are logical and actionable
✓ Agent spawning strategy is well-defined
✓ File is properly saved to templates/skills/
✓ Command can be used immediately without modification

**Final Command Generation Commitment:**
I will now execute EVERY generation step listed above and CREATE PERFECT CUSTOM COMMAND. I will:
- ✅ Analyze user requirements thoroughly
- ✅ SPAWN MULTIPLE AGENTS for pattern analysis and generation
- ✅ Study existing commands to extract exact patterns
- ✅ Generate contextually specific and appropriately formatted command
- ✅ Verify perfect consistency with established style
- ✅ Save completed command to proper location

I will NOT:
- ❌ Create generic or template-based commands
- ❌ Skip any required sections or formatting
- ❌ Accept "close enough" pattern matching
- ❌ Generate commands that don't follow exact style
- ❌ Leave any formatting inconsistencies
- ❌ Stop working while any format deviations remain

**REMEMBER: This is a PERFECT CUSTOM COMMAND GENERATION task, not template copying!**

The command is complete ONLY when it follows exact patterns and serves the specific purpose perfectly.

**Executing comprehensive custom command generation NOW...**