writing-skills

Apply Test-Driven Development principles to create and refine AI skill documentation.

3|2|Updated Dec 28, 2025
One-click install
npx skills add https://github.com/Crumbgrabber/llm_system_template_agents_skills_patterns_tools_prompts --skill writing-skills-crumbgrabber
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-skills
Source: https://github.com/Crumbgrabber/llm_system_template_agents_skills_patterns_tools_prompts/tree/main/skills/writing-skills
Command: npx skills add https://github.com/Crumbgrabber/llm_system_template_agents_skills_patterns_tools_prompts --skill writing-skills-crumbgrabber

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill ensures that new and updated skills are robust, well-tested, and resistant to loopholes by applying Test-Driven Development (TDD) principles to the process of creating and refining documentation.

Core Features & Use Cases

  • TDD for Documentation: Adapts the RED-GREEN-REFACTOR cycle to skill creation, ensuring skills are written only after failing test cases (pressure scenarios) are defined.
  • Bulletproofing Against Rationalization: Provides methods to explicitly close loopholes and address agent rationalizations, making skills more reliable under pressure.
  • Use Case: When developing a new skill for handling complex user authentication, you would first write test scenarios where an agent might try to bypass security. Only after these tests fail would you write the skill's documentation, then re-test to ensure compliance.

Quick Start

Use the writing-skills skill to create a new skill by first defining failing test scenarios and then writing the skill to pass those tests.

Frequently Asked Questions about writing-skills

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I apply TDD principles to AI skill development?

To apply TDD to AI skill development, you define failing test cases and pressure scenarios using subagents before writing the skill. This RED-GREEN-REFACTOR cycle ensures the skill documentation is robust and only written to pass the predefined tests.

How can I prevent my AI agent from rationalizing and bypassing skill documentation?

To prevent agent rationalization, you must define specific pressure scenarios and failing test cases before writing the skill. This approach explicitly closes loopholes by testing the agent against rationalization scenarios and refining the documentation until compliance is achieved.

What is the RED-GREEN-REFACTOR cycle for process documentation?

The RED-GREEN-REFACTOR cycle for process documentation involves defining failing test cases with subagents (RED), writing the skill documentation to pass those tests (GREEN), and refining it to close loopholes (REFACTOR), ensuring robust agent behavior under pressure.

Do I need prior testing experience to use TDD for writing agent skills?

Yes, you need an understanding of Test-Driven Development principles and agent pressure scenarios. Effective implementation requires defining failing test cases with subagents before writing the skill to ensure documentation is resistant to rationalization.

What is the best way to bulletproof complex skill documentation against loopholes?

The best way to bulletproof skill documentation is to define failing test scenarios where an agent might bypass rules, write the skill to pass those tests, and explicitly address rationalizations. This ensures reliability before the skill is finalized.

When should I not use a test-driven approach for skill creation?

You should avoid using a test-driven approach for skill creation if you cannot define clear pressure scenarios or lack understanding of TDD. Without the ability to create failing test cases with subagents, the documentation cannot be effectively validated against loopholes.