$ loading_
Create process documentation with test-driven validation before finalizing the draft.
Copy the install command and let the AI configure it · recommended for beginners
Please install the "Creating Skills" skill from askskill: 1. Download https://raw.githubusercontent.com/obra/clank/main/skills/meta/creating-skills/SKILL.md 2. Save it as ~/.claude/skills/creating-skills/SKILL.md 3. Reload skills and tell me it's ready
Help me write a new employee onboarding process document using a test-driven approach: first list key steps and possible failure points, then design check cases for subagents to execute, and iterate on the document until the steps are clear, unambiguous, and actionable.
A validated onboarding process document with tested steps, risk points, and iteration notes.
I have a draft skill specification. First simulate different subagents following the document, identify misunderstandings, missing conditions, and failure scenarios, then rewrite it into a more rigorous final version.
A refined skill specification improved through execution tests, with clearer structure and more complete edge cases.
Treat this team SOP as a document to test: first generate acceptance criteria, then execute it step by step from multiple role perspectives and log friction points, and finally produce a revised standard operating procedure.
An executable SOP with acceptance criteria, test findings, and revision results.
Creating skills IS Test-Driven Development applied to process documentation.
You write test cases (pressure scenarios with subagents), watch them fail (baseline behavior), write the skill (documentation), watch tests pass (agents comply), and refactor (close loopholes).
Core principle: If you didn't watch an agent fail without the skill, you don't know if the skill teaches the right thing.
See skills/testing/test-driven-development for the fundamental RED-GREEN-REFACTOR cycle. This skill adapts TDD to documentation.
A skill is a reference guide for proven techniques, patterns, or tools. Skills help future Claude instances find and apply effective approaches.
Skills are: Reusable techniques, patterns, tools, reference guides
Skills are NOT: Narratives about how you solved a problem once
| TDD Concept | Skill Creation |
|---|---|
| Test case | Pressure scenario with subagent |
| Production code | Skill document (SKILL.md) |
| Test fails (RED) | Agent violates rule without skill (baseline) |
| Test passes (GREEN) | Agent complies with skill present |
| Refactor | Close loopholes while maintaining compliance |
| Write test first | Run baseline scenario BEFORE writing skill |
| Watch it fail | Document exact rationalizations agent uses |
| Minimal code | Write skill addressing those specific violations |
| Watch it pass | Verify agent now complies |
| Refactor cycle | Find new rationalizations → plug → re-verify |
The entire skill creation process follows RED-GREEN-REFACTOR.
Create when:
Don't create for:
Concrete method with steps to follow (condition-based-waiting, root-cause-tracing)
Way of thinking about problems (flatten-with-flags, test-invariants)
API docs, syntax guides, tool documentation (office docs)
skills/
skill-name/
SKILL.md # Main reference (required)
supporting-file.* # Only if needed
Flat namespace - all skills in one searchable location
Separate files for:
Keep inline:
---
name: Human-Readable Name
description: One-line summary of what this does
when_to_use: Symptoms and situations when you need this (CSO-critical)
version: 1.0.0
languages: all | [typescript, python] | etc
dependencies: (optional) Required tools/libraries
---
# Skill Name
## Overview
What is this? Core principle in 1-2 sentences.
## When to Use
[Small inline flowchart IF decision non-obvious]
Bullet list with SYMPTOMS and use cases
When NOT to use
## Core Pattern (for techniques/patterns)
Before/after code comparison
## Quick Reference
Table or bullets for scanning common operations
## Implementation
Inline code for simple patterns
@link to file for heavy reference or reusable tools
## Common Mistakes
What goes wrong + fixes
## Real-World Impact (optional)
Concrete results
Critical for discovery: Future Claude needs to FIND your skill
Include SYMPTOMS not just abstract use cases:
# ❌ BAD: Too abstract
when_to_use: For async testing
# ✅ GOOD: Symptoms and context
when_to_use: When tests use setTimeout/sleep and are flaky, timing-dependent,
pass locally but fail in CI, or timeout when run in parallel
…
Write evergreen comments focused on what and why, not historical context.
Compare 2-3 approaches before execution to choose a stronger solution.
Plan with pseudocode first, refine approaches, then translate into working code.
Search past Claude Code chats to recover facts, decisions, and context.
Design systems by hiding implementation details behind domain-level interfaces.
Name code by domain meaning to improve clarity and team alignment.
Iteratively test process documentation to find gaps and refine instructions.
Build features, fix bugs, and refactor code with test-driven development.
Implement features and fixes by writing tests before production code.
Execute implementation plans with task-specific subagents and code review checkpoints.
Capture key learnings into reusable repository skills and instructions.
Access and understand Agent Skills specifications and documentation quickly.