菜单
Build a specification-first Digital FTE that orchestrates accumulated intelligence from Lessons 1-7. Learn to compose execution skills into production-ready agents, validate against specifications, and position for monetization.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/majiayu000/claude-skill-registry --skill your-domain-skill命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
LLM token logprobs and calibration. Per-decision confidence, ECE, Brier, reliability diagrams, low-confidence triage.
Analyze LLM token logprobs and calibration. Use for per-decision confidence, ECE, Brier scores, reliability diagrams, and low-confidence triage.
回顾最近 N 天的 Claude Code 使用记录——扫描原始会话数据，按主题分组汇总"我都做了什么"，并从个人操作系统视角输出模式、风险与增删建议。当用户说 /recap、"看看我这几天做了什么"、"回顾一下我最近的会话"、"这两天我用 claude 干了啥"、"活动回顾" 时使用。
基于 SOC 职业分类
正在显示 SKILL.md
| sidebar_position | 8 |
| title | Capstone: Shippable Agent Skill |
| description | Build a specification-first Digital FTE that orchestrates accumulated intelligence from Lessons 1-7. Learn to compose execution skills into production-ready agents, validate against specifications, and position for monetization. |
| keywords | ["capstone project","specification-first design","skill composition","digital FTE production","acceptance testing","skill deployment","monetization strategy","customer-facing execution skill","production safety","business positioning"] |
| chapter | 39 |
| lesson | 8 |
| duration_minutes | 90 |
| skills | [{"name":"Specification-Driven Skill Composition","proficiency_level":"B2","category":"Technical","bloom_level":"Create","digcomp_area":"Problem-Solving","measurable_at_this_level":"Student can write clear specifications for domain-specific execution skills, identifying success criteria, constraints, and integration points for composed subcomponents from Lessons 1-7. Specification drives implementation without requiring clarification."},{"name":"Multi-Component Skill Architecture","proficiency_level":"B2","category":"Technical","bloom_level":"Analyze","digcomp_area":"Problem-Solving","measurable_at_this_level":"Student can design how MCP-wrapping skills, script-execution skills, and orchestration layers combine into cohesive Digital FTE. Student identifies data flow, error recovery paths, and composition dependencies."},{"name":"Acceptance Testing for Production Readiness","proficiency_level":"B2","category":"Technical","bloom_level":"Evaluate","digcomp_area":"Problem-Solving","measurable_at_this_level":"Student can design test scenarios covering success paths, edge cases, error conditions, and business constraints. Student validates that specification ↔ implementation alignment is complete before production claim."},{"name":"Digital FTE Monetization Strategy","proficiency_level":"B2","category":"Applied","bloom_level":"Create","digcomp_area":"Digital Citizenship","measurable_at_this_level":"Student can articulate business value proposition, identify customer segments, select appropriate monetization model (subscription, success-fee, license), and design go-to-market strategy positioning skill as standalone product."}] |
| learning_objectives | [{"objective":"Write specification for domain-specific execution skill that serves a clear customer need with measurable success criteria","proficiency_level":"B2","bloom_level":"Create","assessment_method":"Students complete spec.md with intent, success criteria, constraints, acceptance tests, and architecture design"},{"objective":"Compose 3+ skills from Lessons 1-7 into integrated Digital FTE architecture with clear data flow and error recovery","proficiency_level":"B2","bloom_level":"Analyze","assessment_method":"Students design architecture diagram and implementation plan showing which Lesson skills compose together and how"},{"objective":"Validate skill meets specification through acceptance testing with clean data, edge cases, and failure scenarios","proficiency_level":"B2","bloom_level":"Evaluate","assessment_method":"Students run skill against 5+ test scenarios, document results, identify any spec gaps, and remediate"},{"objective":"Package skill as deployable artifact and create business positioning for monetization","proficiency_level":"B2","bloom_level":"Create","assessment_method":"Students create customer-facing documentation, pricing model proposal, and positioning statement for their Digital FTE"}] |
| cognitive_load | {"new_concepts":11,"assessment":"11 concepts (specification-first capstone, skill composition architecture, acceptance testing framework, test scenario design, spec ↔ implementation validation, error path testing, business value articulation, monetization models, customer segmentation, go-to-market positioning, production readiness criteria). L4 capstone has no upper limit per constitution ✓"} |
| differentiation | {"extension_for_advanced":"Design a skill composition that integrates 5+ components from this chapter. Implement canary deployment strategy with A/B testing for monetization model. Create monitoring/observability for production skill—how would you track performance, detect failures, and optimize based on customer usage? Design customer feedback loop that informs skill evolution.","remedial_for_struggling":"Start with a simpler domain (data validation rather than transformation). Focus first on completing ONE specification → implementation cycle with a single composed skill. Use the provided capstone template and walk through each section with AI guidance. Practice writing ONE acceptance test and validating it passes before expanding to full test suite."} |
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.
In the agent economy, the developers who win are those who can:
This capstone exercises all five. You're not learning to code faster. You're learning to build products that customers pay for.
Before any implementation, define what problem you're solving for whom.
Choose a domain where you have expertise or strong interest. This skill should solve a real problem you've experienced or observed:
Domain Categories:
Real Examples:
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.
Create a skill-spec.md that answers these questions:
## 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)]
Define 5-7 measurable success criteria that a customer would use to evaluate if the skill works:
## 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")
Define explicit boundaries—what this skill does NOT do:
## 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]
Write concrete test cases proving each success criterion:
## 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 validation]
### Test 5: Error Recovery
Input: [malformed_data.csv]
Expected: [skill detects issue, suggests fix, asks for confirmation]
Pass/Fail Criteria: [user can recovery without restarting]
Map which skills from Lessons 1-7 you'll use:
## Architecture
### Component 1: Data Ingestion (Lesson 4 - MCP Wrapping)
- Which MCP? [e.g., "Salesforce connector MCP from Chapter 37"]
- Skill wrapping it: [e.g., "sales-data-fetcher skill"]
- What it does: Fetches data, validates format, transforms to internal schema
### Component 2: Data Analysis (Lesson 6 - Script Execution)
- Script type: [Python, Bash, SQL]
- Skill orchestrating it: [e.g., "anomaly-detector skill"]
- What it does: Runs analysis script, catches errors, retries on failure
### Component 3: Workflow Coordination (Lesson 7 - Orchestration)
- Master skill: [e.g., "sales-analyzer orchestrator"]
- Coordination: Calls Component 1 → Component 2 → generates report
- Error recovery: If Component 2 fails, Component 3 retries with constraints
### Data Flow
[Diagram showing: MCP Input → Component 1 → Component 2 → Component 3 → Output]
With specification complete, design how components integrate.
Which skills call which?
orchestrator-skill (master coordinator)
├─ mcp-wrapping-skill (data source)
│ └─ Context7 MCP (external data)
├─ script-execution-skill (analysis)
│ └─ Python code generation
└─ validation-skill (error checking)
└─ Test data against spec
How does each skill accept/produce data?
## Data Contracts
### MCP-Wrapping Skill Input/Output
Input: {source: "salesforce", filters: {...}}
Output: {records: [...], schema: {...}, validation_passed: bool}
### Script-Execution Skill Input/Output
Input: {data: [...], analysis_type: "anomaly_detection", params: {...}}
Output: {results: [...], errors: [...], iterations: n}
### Orchestrator Skill Input/Output
Input: {customer_id: "...", report_type: "weekly", confidence_threshold: 0.8}
Output: {report: {...}, success: bool, issues_requiring_human_review: [...]}
What happens when each component fails?
## Error Recovery Strategy
### If MCP Fails (Network timeout, auth issue)
→ Retry 3x with exponential backoff
→ If still failing, return cached data (if available) with staleness warning
→ If no cache, escalate to human with actionable error
### If Script Execution Fails (Bad data format)
→ Log specific error message
→ Generate corrected input (remove nulls, handle encoding)
→ Retry script execution with modified input
→ If still failing after 3 iterations, flag for manual review
### If Orchestrator Detects Inconsistency
→ Example: Analysis claims "high growth" but raw data shows decline
→ Generate diagnostic to investigate root cause
→ Present both interpretations to user
→ Ask user to validate which interpretation is correct
Now you have a clear spec. Time to build.
Work with AI to implement your SKILL.md file that orchestrates all components:
---
name: "your-domain-skill"
version: "1.0.0"
description: "[From your spec intent]"
proficiency_level: "B2"
category: "Applied"
---
# Persona
You are a [domain] execution orchestrator. Your job is to:
1. Accept customer specifications from intent above
2. Invoke appropriate data sources (MCP-wrapping skill)
3. Execute analysis (script-execution skill)
4. Validate results against success criteria
5. Generate human-readable output
6. Flag confidence issues for human review
7. Iterate if partial success until spec satisfaction
...
Before testing the full orchestration, validate each component works:
As you build, document why you made each architectural choice:
## Implementation Notes
### Why we chose [MCP X] over [MCP Y]
- Comparison: [criteria]
- Decision: X provides [advantage] that Y lacks
### Why error recovery retries 3x maximum
- Risk: Infinite loops would timeout
- Benefit: 3x usually sufficient for transient failures
- Tradeoff: Some failures might need manual intervention
### Why we validate output against original spec
- Purpose: Ensure analysis actually answers customer question
- Example: If spec asked for "anomalies" and we found "seasonal patterns", both valid but different
Production readiness means: Every acceptance test passes. No exceptions.
Execute each test case from your spec:
## Test Results
### Test 1: Accuracy on Clean Data
- Input: clean_data.csv (100 records)
- Expected: 95%+ anomaly detection accuracy
- Actual: ✓ PASS (97.2% accuracy)
### Test 2: Robustness to Missing Values
- Input: data_with_nulls.csv (50 records, 15% nulls)
- Expected: Handles nulls intelligently
- Actual: ✓ PASS (Imputes using mean, documents assumptions)
### Test 3: Performance at Scale
- Input: 1000_records.csv
- Expected: <30 seconds
- Actual: ✓ PASS (24.3 seconds)
### Test 4: Integration with MCP
- Input: Real Salesforce data
- Expected: Processes without format errors
- Actual: ✓ PASS (5 test runs, 0 format failures)
### Test 5: Error Recovery
- Input: malformed_data.csv (bad encoding)
- Expected: Detects error, asks user
- Actual: ✓ PASS (Error caught, user prompted, recovery successful)
If testing reveals issues, update specification:
## Discovered During Validation
### Issue 1: Specification was unclear about timezone handling
- Original: "Process timestamps from multiple regions"
- Realized: Didn't specify how to normalize timezones
- Updated Spec: "Normalize all timestamps to UTC before analysis, document source timezone in output"
- Test Added: Verify timezone conversion accuracy
### Issue 2: Edge case not covered: Empty dataset
- Original spec didn't mention: "What if data has 0 records?"
- Solution: Return empty results with explanatory message
- Updated spec: "If input has <1 record, return {success: true, records_processed: 0, message: '...'}"
Now package the skill for customers to use.
Write a simple guide customers will use:
# [Your Skill] User Guide
## What This Does
[2-3 sentence summary of business value]
## What You Need
- Input data format: [CSV / database connection / API]
- Required fields: [column names or schema]
- Recommended data size: [e.g., "Works best with 100-10,000 records"]
## How to Use It
1. [Step 1]
2. [Step 2]
3. [Step 3]
## Understanding Results
[Explain key fields in output]
## Troubleshooting
**Problem**: [Common failure scenario]
**Solution**: [How to fix]
## Support
Contact: [your email]
Response time: [e.g., "24 hours"]
Use semantic versioning:
version: "1.0.0" # Major.Minor.Patch
# Major: Breaking changes to input/output format
# Minor: New features that are backward compatible
# Patch: Bug fixes
How does a customer deploy this skill?
## Installation
### Option 1: Claude Code (Recommended)
1. Save this SKILL.md file to ~/.claude/skills/your-domain-skill/SKILL.md
2. In Claude Code, type: /skill-list to see your new skill
3. Activate it: /skill-activate your-domain-skill
4. Test it: Ask Claude "Help me analyze my data with your-domain-skill"
### Option 2: Custom Integration
[For customers integrating with their own LLM provider]
Finally, position this skill as a product.
Who would pay for this?
## Customer Profile
### Primary Segment
- Title: [e.g., "Sales Manager at B2B SaaS companies"]
- Pain point: [specific problem they face]
- Current solution: [what they do today, poorly]
- Budget: [How much would they pay monthly/annually?]
### Secondary Segments
[Other customer types who might benefit]
Why should customers choose your skill over alternatives?
## Value Proposition
**Problem**: [Customer's current pain]
**Our solution**: [What this skill does]
**Outcome**: [Specific business result]
**Differentiation**: [Why ours is better than]
- Alternative 1: [comparison on key dimension]
- Alternative 2: [comparison on key dimension]
### ROI Calculation
- Time saved per week: [X hours]
- Cost per hour: [$Y]
- Monthly savings: [X × Y × 4.33 weeks = $Z]
- Skill cost: [$P/month]
- Payback period: [Z/P months]
Choose how you'll charge:
## Monetization Model
### Option 1: Subscription
- Price: $[X]/month or $[Y]/year
- Users included: [1 / unlimited]
- Data volume: [up to X records/month]
- Pros: Predictable revenue, customer lock-in
- Cons: Requires ongoing support
### Option 2: Success Fee
- Price: [X%] of business value generated
- Example: "2% of monthly savings" or "5% of revenue increase"
- Pros: Aligned incentives, higher ceiling
- Cons: Requires tracking customer results
### Option 3: License
- Price: $[X] one-time fee for unlimited use
- Pros: Simple, customer owns it
- Cons: No recurring revenue
### Recommendation
[Which model fits this skill best and why?]
How will customers find and adopt your skill?
## Go-to-Market Strategy
### Positioning
"[Your skill] is the [category] for [audience] that [specific benefit]."
Example: "sales-analyzer is the revenue intelligence tool for B2B SaaS sales leaders that identifies growth opportunities in 5 minutes instead of 5 hours."
### Customer Acquisition
1. [Channel 1]: [Tactic]
- Target: [Who you'll reach]
- Cost: [acquisition cost]
- Conversion: [estimated %]
2. [Channel 2]: [Tactic]
### Success Metrics
- Month 1: [X customers]
- Month 3: [X customers]
- Month 6: [X customers]
- Target: [$Y MRR by month 12]
This is where you move from learning patterns to building products.
Ask AI to review your domain choice and help sharpen your specification:
I'm building a Digital FTE in [domain] that solves [customer problem].
My current specification:
- Intent: [your intent statement]
- Success criteria: [your success criteria]
- Non-goals: [your constraints]
Review my specification. Is it:
1. Specific enough that you could implement without asking clarifying questions?
2. Focused enough (not trying to solve everything)?
3. Measurable (could you write a test that proves it works)?
If any answer is "no", what's missing from my specification?
What you're learning: How clear specifications prevent implementation rework. Vague specs require clarification loops; clear specs compile cleanly.
Have AI help you design which skills compose together:
I need to compose skills from Chapter 39 into an orchestrator that implements my specification above.
The skills I have available:
- Lesson 1: [Advanced Skill Patterns]
- Lesson 2: [Skill Composition patterns]
- Lesson 3-4: [MCP-wrapping skill for my data source]
- Lesson 5-6: [Script-execution skill for my analysis]
- Lesson 7: [Orchestration skill combining them]
Design an architecture showing:
1. Which skills I should compose
2. Data flow between them
3. Error recovery if any component fails
4. How each component validates its output before passing to next
Draw a diagram using ASCII or describe in text.
What you're learning: Composition thinking—reusing tested components rather than building from scratch. This is Digital FTE production practice.
Ask AI to help implement while you validate each decision:
Implement my orchestrator skill (SKILL.md) that composes the architecture above.
As you implement, explain:
1. Why you chose this persona for the orchestrator
2. What decision questions activate autonomous behavior
3. How error recovery paths will work in practice
4. Which parts need explicit safety constraints
Then, let's test it against my acceptance criteria:
[Paste your 5-7 success criteria]
Create a test plan showing which tests validate which criteria.
What you're learning: How specifications drive implementation. AI uses your spec to make decisions without ambiguity. If it needs to guess, your spec was incomplete.
Run your tests and document what happens:
I ran my skill against my test data with these results:
[Paste your test results]
Issues discovered:
1. [Issue 1 and what caused it]
2. [Issue 2 and what caused it]
For each issue, should I:
- Fix the skill implementation?
- Update the specification to be more accurate?
- Both?
Help me update either the spec or the implementation to make all tests pass.
What you're learning: The specification ↔ implementation feedback loop. Tests reveal gaps in both. Fixing only the code misses the root cause (underspecified requirements).
Finally, articulate why someone would pay for this:
I've built a working Digital FTE that [what it does]. Now help me position it as a product:
1. What customer segment has the most acute version of this problem?
2. What's the annual cost of them NOT having this solution? (time wasted, missed revenue, etc.)
3. What would be a fair price that captures 20-30% of that value?
4. What should my go-to-market strategy focus on (direct sales, self-serve, marketplace)?
5. What's one surprising use case for this skill that customers might not think of?
Use this to help me write a positioning statement and pricing proposal.
What you're learning: Digital FTEs aren't just technical products—they're customer solutions. This prompt teaches the business side of the agent economy.
Your capstone is complete when:
Specification Phase:
Implementation Phase:
Validation Phase:
Production Phase:
Business Phase:
If you get stuck, use this template:
---
name: "my-digital-fte-skill"
version: "1.0.0"
description: "Production-ready skill orchestrating code execution pattern"
proficiency_level: "B2"
---
# Specification
## Intent
[2-3 sentences describing customer problem and solution]
## Success Criteria
1. [Measurable criterion 1]
2. [Measurable criterion 2]
3. [Measurable criterion 3]
## Non-Goals
- Does NOT: [explicit boundary 1]
- Does NOT: [explicit boundary 2]
## Architecture
[Component 1] → [Component 2] → [Component 3] → Output
# Persona
You are a [domain] orchestrator that:
1. [Action 1]
2. [Action 2]
3. [Action 3]
# Questions
- [Question 1: What analysis is needed?]
- [Question 2: What data validates success?]
- [Question 3: What errors require human intervention?]
# Principles
- [Principle 1: Safety/Reliability]
- [Principle 2: Completeness]
# Implementation
[Your skill implementation details]
# Business Positioning
- **Customer**: [Who pays]
- **Problem**: [What pain]
- **Value**: [Specific outcome]
This capstone represents mastery of one critical truth: In the agent economy, your value is not your code. Your value is your specification and your composition skills.
You've now learned that the developers who build billion-dollar AI businesses are exactly those who:
You just completed all four. This skill is now deployable—it could be sold as-is through subscription, license, or success-fee model. Scale this process across multiple skills, and you're building the Digital FTE empire that will define the next decade of software.