writing-skills

Apply test-driven development cycles to validate skill documentation with pressure scenarios.

Updated Oct 22, 2025
One-click install
npx skills add https://github.com/franroa/chezmoi --skill writing-skills-franroa
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-skills
Source: https://github.com/franroa/chezmoi/tree/main/dot_opencode/superpowers/skills/writing-skills
Command: npx skills add https://github.com/franroa/chezmoi --skill writing-skills-franroa

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill guides you in creating robust, effective AI skills by applying Test-Driven Development (TDD) to process documentation. It ensures your skills are clear, discoverable, and resist rationalization, preventing future AI agents from bypassing critical practices.

Core Features & Use Cases

  • TDD for Documentation: Teaches you to write test cases (pressure scenarios), watch them fail (baseline behavior), write the skill, watch tests pass (agent compliance), and refactor (close loopholes).
  • Claude Search Optimization (CSO): Provides critical guidance on writing rich descriptions, using keywords, and optimizing naming for skill discovery.
  • Bulletproofing Against Rationalization: Offers techniques to explicitly close loopholes, address "spirit vs. letter" arguments, and build rationalization tables to make skills resistant to bypass.
  • Use Case: When you identify a reusable technique or pattern, use this Skill to formalize it into a new AI skill. For example, if you discover a new debugging method, this Skill will guide you to document it, test it with subagents under pressure, and ensure it's bulletproof before deployment.

Quick Start

Announce skill usage

I'm using the writing-skills skill to create a new 'code-refactoring' skill.

The skill will then guide you through the TDD cycle for documentation.

Frequently Asked Questions about writing-skills

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

FAQPage Schema
How do I apply test-driven development to document AI skills?

Test-driven development for skill documentation means writing test cases (pressure scenarios) first, watching them fail with baseline behavior, then writing the skill to pass tests, and refactoring to close loopholes. This ensures your skill resists rationalization and agent bypass attempts before deployment.

What's the best way to prevent AI agents from bypassing my skill documentation?

Bulletproof skills by explicitly closing rationalization loopholes through pressure-scenario testing with subagents, building rationalization tables that address "spirit vs. letter" arguments, and enforcing RED-GREEN-REFACTOR cycles. This proactive approach makes skills resistant to bypass and compliance drift.

How do I optimize skill discovery through Claude Search?

Optimize skill discoverability by writing rich descriptions with targeted keywords, using domain vocabulary in naming, and structuring documentation for search intent. The writing-skills approach guides keyword placement and naming conventions to increase findability for users searching related tasks.

When should I formalize a debugging technique or pattern into a reusable skill?

Formalize a technique into a skill when you've identified a reusable pattern that solves a recurrent problem. Use test-driven documentation to validate the pattern under pressure scenarios, ensure clarity for discovery, and bulletproof it against rationalization before publishing for others to adopt.

Can I use test-driven development to improve existing skill documentation?

Yes. Apply TDD retrospectively by writing pressure-scenario tests against existing documentation, identifying gaps where agents might rationalize exceptions, refactoring the documentation to close those gaps, and verifying compliance through subagent testing cycles.

What's the difference between writing clear skill documentation and writing bulletproof documentation?

Clear documentation explains what a skill does; bulletproof documentation anticipates how agents might rationalize bypassing it and explicitly closes those loopholes. Test-driven refinement surfaces rationalization vectors through pressure scenarios, transforming clarity into resistance to agent drift.