writing-plans

Generate step-by-step implementation plans with file paths, code snippets, and commit messages.

Updated Mar 26, 2025
One-click install
npx skills add https://github.com/GSU-FrankJ/tournament_experiment --skill writing-plans-gsu-frankj
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/GSU-FrankJ/tournament_experiment/tree/main/.cursor/skills/writing-plans
Command: npx skills add https://github.com/GSU-FrankJ/tournament_experiment --skill writing-plans-gsu-frankj

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses the challenge of onboarding engineers to new codebases by providing meticulously detailed, step-by-step implementation plans that require zero prior context.

Core Features & Use Cases

  • Context-Free Planning: Generates plans assuming the engineer knows nothing about the codebase or problem domain.
  • Bite-Sized Tasks: Breaks down complex features into small, actionable steps (2-5 minutes each).
  • TDD Focused: Emphasizes writing failing tests first, then minimal implementation, and verification.
  • Use Case: When a new feature is requested, use this Skill to generate a complete roadmap for its implementation, including specific file modifications, test cases, and commit messages.

Quick Start

Use the writing-plans skill to generate an implementation plan for adding a new user authentication module.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I generate detailed implementation plans for onboarding engineers to a new codebase?

Generate detailed implementation plans by creating context-free, bite-sized steps that assume zero prior codebase knowledge. This approach provides exact file paths, code snippets, and testing instructions to seamlessly onboard engineers without needing additional background.

What is the best way to break down complex software features into actionable agile tasks?

The best way to break down complex software features into actionable agile tasks is structuring work into small, verifiable steps of 2-5 minutes each. This ensures each phase yields a testable, commit-ready increment that maps directly to your development workflow.

How do I structure implementation plans for TDD-focused development?

Structure implementation plans for TDD-focused development by ordering tasks to write failing tests first, followed by minimal implementation, and concluding with verification. This sequence guarantees validated, incremental progress with clear commit boundaries for each feature slice.

Can I generate context-free implementation plans that require no prior domain knowledge?

Yes, you can generate context-free implementation plans that require no prior domain knowledge. These plans meticulously detail every necessary file modification, code snippet, and test case, assuming the implementer knows nothing about the problem domain.

What should be included in an implementation plan to ensure smooth feature delivery?

An implementation plan for smooth feature delivery should include exact file paths, relevant code snippets, specific testing instructions, and predefined commit messages. This ensures a complete roadmap that requires no additional context from the implementer.

When do I need a step-by-step implementation plan for software development?

You need a step-by-step implementation plan for software development when onboarding engineers to new codebases or tackling complex features. It ensures work is broken into small, verifiable steps that facilitate TDD and agile practices without requiring prior context.