writing-skills

Enforce TDD and documentation standards for AI skills.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/rahulsc/forge --skill writing-skills-rahulsc
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-skills
Source: https://github.com/rahulsc/forge/tree/main/skills/writing-skills
Command: npx skills add https://github.com/rahulsc/forge --skill writing-skills-rahulsc

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill ensures that your AI-driven processes and documentation are clear, effective, and robust by applying rigorous testing and documentation best practices, preventing common AI errors and rationalizations.

Core Features & Use Cases

  • Skill Authoring: Guides the creation of new AI Skills, ensuring they meet quality standards.
  • Test-Driven Development for Skills: Implements the RED-GREEN-REFACTOR cycle for documentation, ensuring skills are validated before deployment.
  • Rationalization Prevention: Provides techniques to bulletproof skills against AI attempts to bypass rules or find loopholes.
  • Use Case: When developing a new skill for code review, use this skill to define test scenarios, write the skill to enforce best practices, and then refactor it to prevent the AI from skipping steps under pressure.

Quick Start

Use the writing-skills skill to create a new skill by following the RED-GREEN-REFACTOR process.

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 AI skill authoring?

AI skill authoring uses test-driven development by implementing a RED-GREEN-REFACTOR cycle for documentation. This defines test scenarios first, writes the skill to pass them, and refactors to ensure validated compliance before deployment.

How do I prevent AI rationalization and rule bypassing in process documentation?

Preventing AI rationalization requires bulletproofing skills against agents finding loopholes to bypass rules. This involves rigorous documentation standards and specific techniques to stop the AI from skipping steps under pressure.

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

The RED-GREEN-REFACTOR cycle for documentation is a testing methodology where you define failing test scenarios, write the skill to pass them, and then refactor it to improve AI agent performance and ensure compliance.

Can I use this methodology to edit and verify existing AI skills?

Yes, this methodology addresses the editing and verification of skills. It enforces testing and documentation standards to verify that existing skills maintain compliance and prevent rationalization during updates.

Do I need prior TDD knowledge to implement rigorous AI documentation standards?

Yes, you need an understanding of test-driven development principles. Applying TDD concepts to process documentation is required to effectively enforce compliance, validate skills, and prevent rationalization.

What is the best way to structure test scenarios for new code review skills?

The best way to structure test scenarios for code review skills is using a test-driven methodology. Define scenarios first, write the skill to enforce best practices, and refactor to prevent the AI from skipping steps under pressure.