skills.rest
iani-kuli
iani-kuliCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

writing-plans

Generate test-driven implementation plans with file-level task mappings.

Updated May 5, 2026
Search Tags:#planning#tdd#development#architecture#implementation#task-decomposition
One-click install
npx skills add https://github.com/iani-kuli/harness_bro --skill writing-plans-iani-kuli
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/iani-kuli/harness_bro/tree/main/.claude/skills/curated/writing-plans
Command: npx skills add https://github.com/iani-kuli/harness_bro --skill writing-plans-iani-kuli

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill solves the problem of vague or poorly scoped development tasks by forcing a rigorous, test-driven decomposition of requirements before any code is written.

Core Features & Use Cases

  • Task Decomposition: Breaks complex features into bite-sized, 2-5 minute actionable steps.
  • TDD Enforcement: Mandates the creation of failing tests before implementation to ensure code quality.
  • Use Case: When starting a new feature, use this skill to generate a detailed implementation plan that maps out file changes, test cases, and commit points, ensuring the engineer has a clear roadmap.

Quick Start

Use the writing-plans skill to generate an implementation plan for the new user authentication module based on the provided requirements.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I break down a complex software feature into bite-sized implementation tasks?▼

To break down a complex software feature, generate a structured implementation plan that decomposes requirements into bite-sized, 2-5 minute actionable steps with explicit file-level task mapping.

What is the best way to plan a multi-step development task using TDD principles?▼

Planning a multi-step development task with TDD requires mandating the creation of failing tests before implementation, ensuring clear architectural boundaries and verifiable code changes at each commit point.

How do I map out file changes and test cases before writing any code?▼

Mapping out file changes and test cases requires generating a comprehensive implementation plan that enforces test-driven decomposition, providing a clear roadmap of explicit file-level modifications before any code is written.

Does generating a test-driven implementation plan work for vague or poorly scoped development tasks?▼

Generating a test-driven implementation plan is specifically designed for vague or poorly scoped development tasks, forcing a rigorous decomposition of requirements to establish clear architectural boundaries before coding begins.

Can I use task decomposition to define clear architectural boundaries for new feature development?▼

Task decomposition defines clear architectural boundaries for new feature development by breaking complex requirements into bite-sized, buildable steps and explicit file-level task mapping.

When should I not use a test-driven implementation plan for software development?▼

You should avoid using a test-driven implementation plan for simple, single-step modifications that do not require clear architectural boundaries or explicit file-level task mapping to ensure buildable code changes.

Related Skills

Explore More Software Engineering Skills→
arthrodarthrod

writing-plans

Generate structured, test-driven implementation plans with file-level task mapping.

Community
Advanced
danshapirodanshapiro
198

trycycle-planning

Generates step-by-step implementation plans with file modifications, tests, and execution commands.

Community
Intermediate
koolerkxkoolerkx

incremental-implementation

Break large features into small testable slices with continuous verification.

Community
Advanced
raybirdraybird
1

writing-plans

Generate test-driven implementation plans with task decomposition and file paths.

Community
Advanced