Generated Skill

YAML
---
name: example-skill
description: Analyzes data patterns and generates insights. Use when processing datasets or identifying trends.
---

# Intent Analysis
Problem: Transform raw data into actionable insights
Users: Data analysts, researchers, decision makers
Output: Structured analysis with recommendations

# Reasoning Workflow
Step 1: Parse and validate input data
Step 2: Identify analysis objectives
Step 3: Select appropriate analytical methods
Step 4: Execute analysis with tool support
Step 5: Validate findings for accuracy
Step 6: Generate structured insights
Step 7: Provide actionable recommendations

Progress:

• Intent Analysis: Define problem, users, and expected output
• Reasoning Pipeline: Design 7-step chain-of-thought workflow
• Tool Integration: Map tools to workflow steps
• Edge Case Planning: Define fallback strategies
• Claude-Style Thinking: Add self-validation and clarification
• Structure Assembly: Combine all components
• Quality Review: Ensure professional AI agent behavior

Step 1: Deep Intent Analysis

Before writing any code, ask:

• What specific problem does this skill solve?
• Who is the target user and their context?
• What tools might be needed?
• What does success look like?

Step 2: Reasoning Workflow Design

Create a 7-step pipeline:

1. Input Understanding: Parse and validate
2. Clarification: Identify missing information
3. Task Decomposition: Break into subtasks
4. Tool Selection: Choose appropriate tools
5. Execution: Step-by-step processing
6. Validation: Check accuracy and completeness
7. Optimization: Refine output quality

Step 3: Tool Integration Mapping

For each relevant tool, define:

• Trigger condition: When to use
• Input format: What data to send
• Expected output: What to expect back
• Fallback strategy: What if it fails

Step 4: Claude-Style Behavior Integration

Add reasoning behaviors:

• Ask clarifying questions before proceeding
• Show uncertainty when appropriate
• Provide step-by-step explanations
• Self-check work before final output
• Consider multiple approaches

Example 1: Input: "Create a skill for code review" Output:

YAML
---
name: reviewing-code
description: Performs comprehensive code analysis with security, performance, and style checks. Use when reviewing pull requests or auditing codebases.
---

# Intent Analysis
Problem: Ensure code quality and catch issues before deployment
Users: Senior developers, technical leads, DevOps engineers
Output: Detailed review with prioritized issues and suggestions

# Reasoning Workflow
Step 1: Parse code structure and language
Step 2: Clarify review scope and standards
Step 3: Break review into: security, performance, style, logic
Step 4: Execute static analysis tools if available
Step 5: Perform manual reasoning for complex logic
Step 6: Validate findings against best practices
Step 7: Prioritize issues and format recommendations

Example 2: Input: "Build a skill for market research" Output:

YAML
---
name: researching-markets
description: Conducts comprehensive market analysis with competitor research and trend identification. Use when evaluating business opportunities or strategic planning.
---

# Tool Integration
- search: Gather market data and competitor information
- generate_text: Synthesize findings into reports
- When search fails: Use provided data only, note limitations

Reasoning Design:

• Always include 7-step workflow (understand → clarify → decompose → select tools → execute → validate → optimize)
• Make each step specific and actionable
• Include self-validation at each stage

Tool Integration:

• Map tools to specific workflow steps
• Define clear trigger conditions
• Always include fallback strategies
• Specify expected input/output formats

Claude-Style Behavior:

• Ask clarifying questions when input is ambiguous
• Show reasoning process explicitly
• Acknowledge uncertainty appropriately
• Provide multiple approaches when relevant

Structure:

• Start with intent analysis (problem/users/output)
• Follow with reasoning workflow
• Include tool integration section when relevant
• Add edge cases and examples
• Keep total length under 500 lines

Shallow Thinking:

• Don't rush to implementation
• Always start with deep intent analysis
• Design reasoning workflow before writing examples

Tool Misuse:

• Don't add tools without clear purpose
• Don't ignore fallback strategies
• Don't assume tools always work

Missing Claude Behavior:

• Don't skip clarifying questions
• Don't hide reasoning process
• Don't ignore uncertainty
• Don't provide single-path solutions

Structural Issues:

• Don't skip YAML frontmatter validation
• Don't exceed 500-line recommended length
• Don't forget edge case handling
• Don't omit concrete examples