Skill Patterns That Work: From Sequential Workflows to Domain Intelligence

Part 4 of a 5-part series on building production-grade skills for Claude

Previous: Part 3: Building Your First Skill | Next: Part 5: Testing, Debugging, and Distributing

These patterns emerged from skills built by early adopters and Anthropic’s internal teams, and they represent common approaches that work well rather than prescriptive templates. Pick the one that matches your use case.

Problem-First vs. Tool-First

Before choosing a pattern, decide your framing:

Problem-first: “I need to set up a project workspace” → Your skill orchestrates the right MCP (Model Context Protocol) calls in sequence, where users describe outcomes and the skill handles tools.
Tool-first: “I have Notion MCP connected” → Your skill teaches Claude optimal workflows and best practices, where users have tool access and the skill provides expertise.

Most skills lean one direction, and knowing which one helps you pick the right pattern.

Pattern 1: Sequential Workflow Orchestration

Use when: Multi-step processes must execute in a specific order.

# Workflow: Onboard New Customer

## Step 1: Create Account
Call MCP tool: `create_customer`
Parameters: name, email, company

## Step 2: Setup Payment
Call MCP tool: `setup_payment_method`
Wait for: payment method verification

## Step 3: Create Subscription
Call MCP tool: `create_subscription`
Parameters: plan_id, customer_id (from Step 1)

## Step 4: Send Welcome Email
Call MCP tool: `send_email`
Template: welcome_email_template

Key techniques: Explicit step ordering, dependencies between steps, validation at each stage, rollback instructions for failures.

This is the bread-and-butter pattern for most MCP-enhanced skills, and the critical detail is data passing between steps, since Step 3 needs the customer_id from Step 1. Make these dependencies explicit in your instructions.

Pattern 2: Multi-MCP Coordination

Use when: Workflows span multiple services.

This pattern coordinates across different MCP servers in distinct phases. A design-to-development handoff might look like:

# Phase 1: Design Export (Figma MCP)
1. Export design assets from Figma
2. Generate design specifications
3. Create asset manifest

# Phase 2: Asset Storage (Drive MCP)
1. Create project folder in Drive
2. Upload all assets
3. Generate shareable links

# Phase 3: Task Creation (Linear MCP)
1. Create development tasks
2. Attach asset links to tasks
3. Assign to engineering team

# Phase 4: Notification (Slack MCP)
1. Post handoff summary to #engineering
2. Include asset links and task references

Key techniques: Clear phase separation, data passing between MCPs, validation before moving to the next phase, centralized error handling.

The biggest pitfall here is error propagation. If Phase 2 fails, what happens to the data from Phase 1? Your skill should specify recovery behavior — retry the phase, roll back, or flag for manual intervention.

Use when: Output quality improves with iteration.

# Iterative Report Creation

## Initial Draft
1. Fetch data via MCP
2. Generate first draft report
3. Save to temporary file

## Quality Check
1. Run validation script: `scripts/check_report.py`
2. Identify issues:
   - Missing sections
   - Inconsistent formatting
   - Data validation errors

## Refinement Loop
1. Address each identified issue
2. Regenerate affected sections
3. Re-validate
4. Repeat until quality threshold met

## Finalization
1. Apply final formatting
2. Generate summary
3. Save final version

Key techniques: Explicit quality criteria, validation scripts (because code is deterministic while language interpretation is not), and knowing when to stop iterating.

This pattern works exceptionally well when paired with a Python validation script in scripts/. Instead of asking Claude to “check if the report looks good,” have it run a script that programmatically validates structure, data completeness, and formatting rules.

Pattern 4: Context-Aware Tool Selection

Use when: The same outcome requires different tools depending on context.

# Smart File Storage

## Decision Tree
1. Check file type and size
2. Determine best storage location:
   - Large files (>10MB): Use cloud storage MCP
   - Collaborative docs: Use Notion/Docs MCP
   - Code files: Use GitHub MCP
   - Temporary files: Use local storage

## Execute Storage
Based on decision:
- Call appropriate MCP tool
- Apply service-specific metadata
- Generate access link

## Provide Context to User
Explain why that storage was chosen

Key techniques: Clear decision criteria, fallback options, transparency about choices.

The transparency element is important — users trust the skill more when Claude explains why it chose a particular path. This also makes debugging easier when the wrong path is taken.

Pattern 5: Domain-Specific Intelligence

Use when: Your skill adds specialized knowledge beyond what tools provide.

This is the most powerful pattern because it embeds expertise that doesn’t exist in any API:

# Payment Processing with Compliance

## Before Processing (Compliance Check)
1. Fetch transaction details via MCP
2. Apply compliance rules:
   - Check sanctions lists
   - Verify jurisdiction allowances
   - Assess risk level
3. Document compliance decision

## Processing
IF compliance passed:
  - Call payment processing MCP tool
  - Apply appropriate fraud checks
  - Process transaction
ELSE:
  - Flag for review
  - Create compliance case

## Audit Trail
- Log all compliance checks
- Record processing decisions
- Generate audit report

Key techniques: Domain expertise embedded in logic, compliance-before-action ordering, comprehensive audit trail, clear governance rules.

This pattern is where skills differentiate most from raw MCP access. Anyone can connect to a payment API; your skill encodes the institutional knowledge about how to use it correctly.

Combining Patterns

Real-world skills often combine patterns. A data pipeline skill might use:

Sequential orchestration for the main ingestion flow
Context-aware selection to pick the right parser based on file type
Iterative refinement for data quality checks
Domain intelligence for business rule validation

Don’t force your skill into a single pattern. Use what fits each phase of the workflow.

Anti-Patterns to Avoid

Overloading a single skill. If your skill handles more than 3 to 4 distinct workflows, split it, because Claude’s description matching works better with focused skills.

Assuming tool availability. Always include fallback behavior, since MCP servers disconnect, API keys expire, and rate limits get hit. Your skill should degrade gracefully.

Vague instructions with implicit expectations. “Make sure everything is correct” means nothing, whereas “Run scripts/validate.py and ensure exit code is 0” is actionable.

Skipping the audit trail. For any skill that modifies external state (creates tickets, sends emails, processes payments), include explicit logging and confirmation steps so that users can verify what happened.

Problem-First vs. Tool-First#

Pattern 1: Sequential Workflow Orchestration#

Pattern 2: Multi-MCP Coordination#

Pattern 3: Iterative Refinement#

Pattern 4: Context-Aware Tool Selection#

Pattern 5: Domain-Specific Intelligence#

Combining Patterns#

Anti-Patterns to Avoid#