39-agent-skills-mcp-code-execution-panaversity-agentfactory

# Capstone: Shippable Agent Skill

You've now learned every pattern this chapter teaches: persona design (Lesson 1), skill composition (Lesson 2), MCP-wrapping (Lessons 3-4), script execution (Lessons 5-6), and workflow orchestration (Lesson 7).

But learning patterns is not the same as building products.

This capstone is different. You're not following steps or solving a predetermined problem. You're doing what every AI-native entrepreneur must do: **articulate a problem clearly enough that AI can build a solution to it, then validate that solution works in the real world.**

You're building a **specification-first Digital FTE**—a complete, shippable execution skill that solves a real customer problem. This skill will orchestrate the accumulated intelligence from all previous lessons, handle production edge cases, and be ready to monetize.

## Why This Capstone Matters

In the agent economy, the developers who win are those who can:

1. **Identify customer problems** that are specific enough to solve but broad enough to charge for
2. **Write specifications clearly** so AI can implement without ambiguity
3. **Compose existing intelligence** rather than reinventing patterns
4. **Validate ruthlessly** that the product works before claiming it's production-ready
5. **Price strategically** to capture value without leaving money on the table

This capstone exercises all five. You're not learning to code faster. You're learning to build products that customers pay for.

## Phase 1: Domain Specification (Spec FIRST)

Before any implementation, define what problem you're solving for whom.

### Select Your Domain

Choose a domain where you have expertise or strong interest. This skill should solve a real problem you've experienced or observed:

**Domain Categories**:

- **Professional Services**: Legal document review, financial analysis, code review, technical writing
- **Content Operations**: Social media scheduling, newsletter writing, content moderation, SEO optimization
- **Data Processing**: Sales pipeline analysis, customer segmentation, report generation, data validation
- **System Operations**: Log analysis, configuration validation, performance monitoring, security compliance
- **Creative**: Image description, metadata generation, caption writing, style adaptation

**Real Examples**:

- **Legal Brief Analyzer**: Ingest case documents, extract relevant precedents, summarize arguments, flag contradictions
- **Sales Data Processor**: Import sales data, identify anomalies, segment customers, forecast pipeline
- **Code Review Enforcer**: Check PRs against team standards, catch security issues, suggest improvements
- **Content Quality Inspector**: Validate blog posts for SEO, readability, brand consistency, factual accuracy

Pick something specific. "Data processing tool" is too vague. "CSV sales data analyzer that identifies top performers, flags stagnant accounts, and generates forecasts" is right-sized.

### Write Your Specification

Create a `skill-spec.md` that answers these questions:

#### Intent (The Customer Problem)

```markdown
## Intent

**What customer problem does this skill solve?**

A [company type] needs to [specific business outcome] but currently [current friction]. This skill [specific solution] enabling them to [measurable business result].

**Example:**
Sales teams need to identify which accounts are growing vs stagnating to prioritize outreach. Currently, managers spend 4-6 hours weekly manually reviewing spreadsheets. This skill analyzes customer transaction history, flags trends, and generates weekly reports in 5 minutes, freeing managers for strategy.

**Why customers would buy:**
- [Time saved per week/month]
- [Cost reduction: (current cost) → (new cost)]
- [Risk reduced: (current failure rate) → (new failure rate)]
- [Revenue impact: (new revenue opportunity OR cost avoidance)]
```

#### Success Criteria (How You'll Know It Works)

Define 5-7 measurable success criteria that a customer would use to evaluate if the skill works:

```markdown
## Success Criteria

- Accuracy: [specific metric] achieved on test data (e.g., "Correctly identifies 95%+ of anomalies in clean data")
- Speed: [completes in X time] (e.g., "Processes 1000 records in under 30 seconds")
- Reliability: [uptime or error rate] (e.g., "Handles 99%+ of real-world data formats without crashes")
- Completeness: [coverage metric] (e.g., "Generates all required report fields with no missing values")
- Safety: [risk mitigation] (e.g., "Flags confidence levels <80% for manual review before acting")
- Integration: [system compatibility] (e.g., "Imports from Salesforce, HubSpot, and CSV formats")
- Learning: [improvement mechanism] (e.g., "Generates error logs enabling continuous pattern improvement")
```

#### Constraints (What's NOT Included)

Define explicit boundaries—what this skill does NOT do:

```markdown
## Constraints (Non-Goals)

- Does NOT: Real-time decision-making (only batch processing)
- Does NOT: Modify source data (analysis only, read-only)
- Does NOT: Handle unstructured text (CSV/database inputs only)
- Does NOT: Provide legal interpretation (flags issues, humans decide)

Why: [reasoning for each boundary]
```

#### Acceptance Tests (Proof of Success)

Write concrete test cases proving each success criterion:

```markdown
## Acceptance Tests

### Test 1: Accuracy on Clean Data
Input: [clean_data.csv with known patterns]
Expected: [specific output meeting criterion]
Pass/Fail Criteria: [measurable validation rule]

### Test 2: Robustness to Missing Values
Input: [data_with_nulls.csv]
Expected: [skill either fills intelligently or flags for review]
Pass/Fail Criteria: [specific error handling rule]

### Test 3: Performance at Scale
Input: [1000_records.csv]
Expected: [completes in <30 seconds]
Pass/Fail Criteria: [timing measurement]

### Test 4: Integration with MCP
Input: [real-world data from Salesforce MCP]
Expected: [processes without format errors]
Pass/Fail Criteria: [data shape va