writing-skills

Enforce a RED-GREEN-REFACTOR test-driven workflow for skill verification and documentation.

80|17|Updated Oct 27, 2025
One-click install
npx skills add https://github.com/withzombies/hyperpowers --skill writing-skills-withzombies
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-skills
Source: https://github.com/withzombies/hyperpowers/tree/main/skills/writing-skills
Command: npx skills add https://github.com/withzombies/hyperpowers --skill writing-skills-withzombies

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill applies Test-Driven Development (TDD) principles to process documentation, ensuring new or edited AI skills are robust, clear, and resistant to rationalization. It prevents deploying ineffective skills by requiring rigorous testing with subagents.

Core Features & Use Cases

  • TDD for Documentation: Guides through a Red-Green-Refactor cycle for skill creation, using subagent "pressure scenarios" as test cases.
  • Rationalization Bulletproofing: Explicitly addresses and counters common agent rationalizations, closing loopholes and enforcing discipline.
  • CSO Optimization: Provides guidelines for Claude Search Optimization (CSO) to ensure skills are easily discoverable and token-efficient.
  • Use Case: When creating a new AI skill, use this Skill to first run a "failing test" (an agent without the skill), then write the skill to address observed failures, and finally refactor to close any new loopholes.

Quick Start

Use the writing-skills skill to create a new skill for managing project dependencies.

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 skill creation?

Test-driven development for skills follows the RED-GREEN-REFACTOR cycle: first run a failing test with an agent lacking the skill, observe failures, write the skill to address those failures, then refactor to close loopholes. This ensures skills are robust and resistant to agent rationalization before deployment.

What is rationalization bulletproofing in AI skill development?

Rationalization bulletproofing explicitly identifies and counters common ways agents justify incorrect behavior or skip steps. By enforcing discipline through pressure scenarios and red-flag checks during skill authoring, you prevent agents from finding workarounds and ensure skills work as intended.

How do I verify a new skill meets functional requirements?

Verify skills by running baseline and passing test artifacts that validate frontmatter (name, description), structured sections, explicit rationalization counters, and red-flag checks. Subagent pressure scenarios serve as test cases to confirm the skill handles edge cases and pressure situations correctly.

What testing workflow should I use before deploying a skill?

Deploy-ready skills require a complete TDD workflow: define pressure scenarios as failing tests, write the skill to pass those tests, refactor to close new loopholes, and validate all test artifacts pass. This pressure-testing approach with subagents ensures the skill is production-ready.

Can I use this approach to update existing skills?

Yes, the TDD workflow applies to both new and edited skills. Run pressure scenarios against the current skill to identify failures, modify the skill to address those failures, then refactor and re-test to ensure no new loopholes emerge from your changes.

How does Claude Search Optimization improve skill discoverability?

CSO guidelines in the skill-writing process ensure skills are token-efficient and easily discoverable through search. Applying CSO during authoring makes skills more findable while reducing unnecessary token usage in documentation and frontmatter.