Create Skill
Create or harden agent skills using TDD on documentation—pressure-test with subagents before you ship SKILL.md.
Overview
create-skill is a journey-wide agent skill that guides TDD-based SKILL.md authoring and verification—usable whenever a solo builder needs to extend agent capabilities before committing to a new or updated skill.
Install
npx skills add https://github.com/neolabhq/context-engineering-kit --skill create-skillWhat is this skill?
- Treats skill authoring as TDD: pressure scenarios, baseline failure, then document until agents comply
- REQUIRED: understand Test-Driven Development skill before using (RED-GREEN-REFACTOR)
- Personal skills paths for Claude Code (~/.claude/skills) and Codex (~/.codex/skills)
- Use for create, edit, or verify skills before deployment
- Iterates to close rationalization loopholes after watching agents fail without the skill
- Core TDD cycle: RED-GREEN-REFACTOR (required background skill)
Adoption & trust: 528 installs on skills.sh; 1.1k GitHub stars; 3/3 security scanners passed (skills.sh audits).
What problem does it solve?
You wrote a skill from intuition and agents still rationalize around it because you never pressure-tested the documentation.
Who is it for?
Builders creating or maintaining personal agent skills who already practice TDD and want reproducible skill quality gates.
Skip if: One-off chat tasks with no reusable workflow, or authors unwilling to run subagent pressure tests before deployment.
When should I use this skill?
When users want to create a new skill, update an existing skill, or verify skills work before deployment.
What do I get? / Deliverables
You ship a skill only after subagent scenarios pass compliance, with loops closed against rationalization—optionally refined with Anthropic best-practices pass.
- Tested SKILL.md skill package
- Documented refactor pass closing agent loopholes
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Author a new integration skill and run subagent scenarios until RED-GREEN-REFACTOR passes.
Verify an updated skill before release so review agents cannot bypass documented gates.
Refactor an internal ops skill after production incidents exposed rationalization gaps.
Document a scoped prototype workflow as a skill once you commit to repeating the process.
How it compares
Meta authoring workflow with TDD gates, not a single-purpose integration skill.
Common Questions / FAQ
Who is create-skill for?
Solo and indie agent users who maintain SKILL.md packages in Claude Code or Codex and want test-driven verification before release.
When should I use create-skill?
When creating a new skill, editing an existing one, or verifying deployment readiness—across Build agent-tooling, Ship review prep, or Operate when you iterate internal playbooks.
Is create-skill safe to install?
It focuses on local skill files and subagent testing; review the Security Audits panel on this Prism page and avoid embedding secrets in SKILL.md.
Workflow Chain
Requires first: test driven development
Then invoke: apply anthropic skill best practices
SKILL.md
READMESKILL.md - Create Skill
# Create Skill Command This command provides guidance for creating effective skills. ## Overview **Writing skills IS Test-Driven Development applied to process documentation.** **Personal skills live in agent-specific directories (`~/.claude/skills` for Claude Code, `~/.codex/skills` for Codex)** 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. **REQUIRED BACKGROUND:** You MUST understand Test-Driven Development before using this skill. That skill defines the fundamental RED-GREEN-REFACTOR cycle. This skill adapts TDD to documentation. **Official guidance:** The Anthropic's official skill authoring best practices provided at the `/apply-anthropic-skill-best-practices` command, they enhance `prompt-engineering` skill. Use skill and the document, as they not copy but add to each other. These document provides additional patterns and guidelines that complement the TDD-focused approach in this skill. ## About Skills Skills are modular, self-contained packages that extend Claude's capabilities by providing specialized knowledge, workflows, and tools. Think of them as "onboarding guides" for specific domains or tasks—they transform Claude from a general-purpose agent into a specialized agent equipped with procedural knowledge that no model can fully possess. ## What is a Skill? 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 ### What Skills Provide 1. Specialized workflows - Multi-step procedures for specific domains 2. Tool integrations - Instructions for working with specific file formats or APIs 3. Domain expertise - Company-specific knowledge, schemas, business logic 4. Bundled resources - Scripts, references, and assets for complex and repetitive tasks ## TDD Mapping for Skills | 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. ## When to Create a Skill **Create when:** - Technique wasn't intuitively obvious to you - You'd reference this again across projects - Pattern applies broadly (not project-specific) - Others would benefit **Don't create for:** - One-off solutions - Standard practices well-documented elsewhere - Project-specific conventions (put in CLAUDE.md) ## Skill Types ### Technique Concrete method with steps to follow (condition-based-waiting, root-cause-tracing) ### Pattern Way of thinking about