writing-skills

Overview

This skill enforces a Test-Driven Development (TDD) approach to documentation and skill authoring. By defining what a skill must achieve before writing its content, we ensure functional clarity and prevent "hallucinated utility" or generic, ungrounded advice.

Iron Law

NO SKILL WITHOUT A FAILING TEST FIRST Skills written without a prior test case often drift into generic filler that doesn't solve a specific user problem. The test case grounds the skill in reality.

State Machine

digraph writing_skills_flow {
    "Start" [shape=doublecircle];
    "Step 1: Define User Problem" [shape=box];
    "Step 2: Write Failing Test Case" [shape=box];
    "Step 3: Define Acceptance Criteria" [shape=box];
    "Step 4: Author Skill Content" [shape=box];
    "Step 5: Run Test Case" [shape=box];
    "Gate: Pass Test?" [shape=diamond];
    "Done" [shape=doublecircle];

    "Start" -> "Step 1: Define User Problem";
    "Step 1: Define User Problem" -> "Step 2: Write Failing Test Case";
    "Step 2: Write Failing Test Case" -> "Step 3: Define Acceptance Criteria";
    "Step 3: Define Acceptance Criteria" -> "Step 4: Author Skill Content";
    "Step 4: Author Skill Content" -> "Step 5: Run Test Case";
    "Step 5: Run Test Case" -> "Gate: Pass Test?";
    "Gate: Pass Test?" -> "Done" [label="pass"];
    "Gate: Pass Test?" -> "Step 4: Author Skill Content" [label="fail"];
}

When to Use This Skill

• Creating a new agent skill from scratch.
• Refactoring an existing skill to add new capabilities.
• Upgrading a rough draft to a production-ready skill.
• Debugging a skill that is producing poor-quality output.

When NOT to Use This Skill

• Simple task execution that does not require a persistent skill instruction.
• General conversational responses.

Core Process

Step 1: Define User Problem

Identify the specific failure mode or knowledge gap the user is facing. What happens when the user doesn't have this skill? (Source: system design)

Step 2: Write Failing Test Case

Draft a sample prompt or scenario where a generic LLM (or the current skill) would fail. This is the "Red" phase of TDD. (Source: system design)

Step 3: Define Acceptance Criteria

List 3-5 specific, testable behaviors the skill MUST exhibit to be considered successful. (Source: system design)

Step 4: Author Skill Content

Write the skill following the appropriate rigor template (full rigor or standard rigor). Every principle must directly address the failure mode identified in Step 1. (Source: system design)

Step 5: Run Test Case

Execute the failing test case from Step 2 against the newly authored skill. If the output meets the acceptance criteria, the skill passes. (Source: system design)

Cross-Skill Invocations

REQUIRED SUB-SKILL: None RECOMMENDED SUB-SKILL: prompt-optimizer — to refine the test case and skill instructions.

Rationalization Table

| Thought | Reality | |---------|---------| | "I know what I want to say, I don't need a test case." | Without a test, you won't know if the skill actually changes the LLM's behavior. | | "Writing the test takes too much time." | Fixing a broken skill after deployment takes 10x more time. | | "This skill is too simple for TDD." | Simple skills are where generic filler is most likely to hide. | | "I'll write the test after I finish the skill." | This defeats the purpose; you will subconsciously write a test the skill can already pass. |

Red Flags

These thoughts mean STOP — you are about to shortcut:

• "Let me just start writing and see where it goes" → You are skipping Step 1 and Step 2.
• "The test case passed even without the skill" → Your test case is too weak; it doesn't represent a true failure mode.
• "I'll just assume this works because it looks comprehensive" → You are skipping Step 5.

Diagnostic Checklist

• [ ] Is there a documented failing test case (prompt/scenario)?
• [ ] Do the acceptance criteria explicitly reference the failing test case?
• [ ] Does every principle in the skill map to a required behavior?
• [ ] Has the skill been tested against the scenario and passed?
• [ ] Is the skill free of generic, non-actionable advice?

Sources

• System design — Pattern Lineage and writing-skills definition.
• System design — Full Rigor format requirements.