writing-skills

Enforce RED-GREEN-REFACTOR cycles for Skill documentation with minimal SKILL.md content.

3|5|Updated Apr 26, 2026
One-click install
npx skills add https://github.com/casualjim/pi-superpowers --skill writing-skills-casualjim
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-skills
Source: https://github.com/casualjim/pi-superpowers/tree/main/skills/writing-skills
Command: npx skills add https://github.com/casualjim/pi-superpowers --skill writing-skills-casualjim

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Writing skills as formal process documentation is prone to vagueness, inconsistent scope, and unverified guidance. This Skill applies test-driven development to Skill creation and editing to ensure every Skill has measurable failing tests, a minimal green implementation, and a robust refactor cycle that closes loopholes before deployment.

Core Features & Use Cases

  • Enforces RED-GREEN-REFACTOR discipline for Skill creation and updates.
  • Captures rationalizations, defines red flags, and supports iterative hardening.
  • Supports progressive disclosure patterns to keep Skill bodies concise while linking to heavy references when needed.

Quick Start

Follow the RED-GREEN-REFACTOR cycle to write and test a Skill, then deploy after verification.

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

Test-driven development for documentation enforces a RED-GREEN-REFACTOR cycle, requiring you to baseline failing scenarios before writing minimal content that passes verification. This ensures every piece of documentation has measurable tests and verified guidance.

What is the RED-GREEN-REFACTOR cycle for skill creation?

The RED-GREEN-REFACTOR cycle for skill creation involves baselining failing tests first, writing minimal SKILL.md content to pass those tests, and iteratively refactoring to close loopholes. This hardening process guarantees compliance before deployment.

How do I track rationalizations when editing process documentation?

Track rationalizations when editing process documentation by maintaining a dedicated rationalization table alongside defined red flags. This supports iterative hardening by capturing loopholes and ensuring explicit tracking across agent domains.

Can I use test-driven development to update existing skills?

Yes, test-driven development applies to both creating new skills and editing existing ones. You baseline failing scenarios for the current skill, write minimal updates to pass tests, and refactor to maintain compliance before deployment.

When should I use progressive disclosure patterns in skill documentation?

Use progressive disclosure patterns in skill documentation when you need to keep the main body concise while still providing heavy references. This approach links to detailed references only when needed, preventing vagueness and inconsistent scope.

Why does my skill documentation have inconsistent scope and unverified guidance?

Skill documentation often has inconsistent scope and unverified guidance due to vague formal process writing. Applying test-driven development with pressure-based cycles and rationalization tracking closes loopholes and ensures measurable compliance.