writing-skills

Validate Claude skill documentation using test-driven development with subagents.

6|1|Updated Oct 23, 2025
One-click install
npx skills add https://github.com/alexsandrocruz/ZenPowers --skill writing-skills-alexsandrocruz
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-skills
Source: https://github.com/alexsandrocruz/ZenPowers/tree/main/skills/writing-skills
Command: npx skills add https://github.com/alexsandrocruz/ZenPowers --skill writing-skills-alexsandrocruz

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill empowers you to create highly effective and robust Claude Skills by applying Test-Driven Development (TDD) principles to process documentation. It ensures skills are clear, discoverable, and resilient against agent rationalization, preventing the deployment of ineffective guidance.

Core Features & Use Cases

  • TDD for Documentation: Guides through the RED-GREEN-REFACTOR cycle for skill creation, using subagents for testing.
  • Claude Search Optimization (CSO): Provides critical guidelines for naming, descriptions, keywords, and token efficiency to maximize skill discovery.
  • Bulletproofing Against Rationalization: Teaches how to explicitly close loopholes, address "spirit vs. letter" arguments, and build rationalization tables.
  • Use Case: When creating new skills, editing existing ones, or verifying skills before deployment, use this Skill to ensure they are high-quality, discoverable, and effective.

Quick Start

TDD Mapping for Skills:

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

SKILL.md Frontmatter Example:

---

name: Skill-Name-With-Hyphens

description: Use when [specific triggering conditions and symptoms] - [what the skill does and how it helps, written in third person]

---

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 documentation?

Test-driven development for skills uses a RED-GREEN-REFACTOR cycle: write a pressure scenario with subagents to establish baseline failure (RED), deploy the skill and verify compliance (GREEN), then refactor to close loopholes while maintaining compliance. This ensures documentation is clear and resistant to agent rationalization before deployment.

What makes a skill resistant to agent rationalization?

Rationalization resistance requires explicitly closing loopholes in skill guidance, addressing "spirit vs. letter" interpretations, and building rationalization tables that anticipate edge cases. The writing-skills Skill teaches how to construct frontmatter metadata and SKILL.md content that leaves no ambiguity for agents to exploit.

How do I optimize a skill for Claude search discovery?

Claude Search Optimization (CSO) applies naming conventions using hyphens, writes descriptions in third person tied to triggering conditions, and selects keywords balancing specificity with search volume. The Skill provides guidelines for token-efficient frontmatter that maximizes discoverability while maintaining clarity.

Can I use this workflow for editing existing skills?

Yes. The TDD workflow applies to creating, editing, and verifying CLAUDE skills. Test your edits with subagent pressure scenarios before deployment to confirm the skill still produces compliant behavior and hasn't introduced new rationalization vectors.

What structure does a skill document need to follow?

A SKILL.md requires frontmatter with name (hyphen-separated), description (third person, triggering conditions + what it does), and concise process documentation. The Skill provides exact frontmatter templates and RED-GREEN-REFACTOR guidance to build documentation that passes validation.

Why is test-driven development better than writing documentation first?

TDD surfaces how agents actually interpret guidance before deployment. Writing pressure scenarios first reveals compliance gaps and rationalization paths that forward documentation alone misses, letting you refactor toward genuine robustness rather than assumed clarity.