writing-plans

Generate implementation plans with exact file paths, code examples, and verification steps.

3|Updated Oct 18, 2025
One-click install
npx skills add https://github.com/DYAI2025/Stoppclock-page --skill writing-plans-dyai2025
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/DYAI2025/Stoppclock-page/tree/main/stoppclock_speckit/.claude/commands/SKILL (14).md
Command: npx skills add https://github.com/DYAI2025/Stoppclock-page --skill writing-plans-dyai2025

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill eliminates ambiguity and reduces onboarding time for engineers by generating highly detailed, bite-sized implementation plans. It ensures that even engineers with zero codebase context can execute tasks efficiently and correctly.

Core Features & Use Cases

  • Bite-Sized Tasks: Break down complex features into small, actionable steps (2-5 minutes each).
  • Exact Instructions: Provide precise file paths, complete code examples, and exact verification commands.
  • Use Case: Hand off a new feature development to a junior engineer or a new team member, confident they have all the information needed to succeed without constant supervision.

Quick Start

Announce: "I'm using the writing-plans skill to create the implementation plan."

Goal: [One sentence describing what this builds]

Architecture: [2-3 sentences about approach]

Tech Stack: [Key technologies/libraries]

Task N: [Component Name]

Files:

- Create: exact/path/to/file.py

- Modify: exact/path/to/existing.py:123-145

- Test: tests/exact/path/to/test.py

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I create detailed implementation plans for engineers with no codebase context?

Implementation plans break down features into bite-sized tasks with exact file paths, complete code examples, and verification steps. This Skill generates comprehensive plans that specify which files to create or modify, include full code blocks, define tests, and provide git-commit instructions—enabling junior or new engineers to execute tasks independently without constant supervision.

What should I include in an implementation plan for a new feature?

An implementation plan includes a one-sentence goal, 2–3 sentences on architecture and approach, the tech stack, and numbered tasks. Each task specifies files to create or modify with exact paths, line ranges for edits, complete code examples, test files, and verification commands. Plans are saved with date-stamped filenames in docs/plans.

Can I use implementation plans to onboard junior engineers faster?

Yes. Implementation plans eliminate ambiguity by providing step-by-step guidance with precise file locations and code examples. Junior engineers can execute 2–5 minute tasks sequentially without needing deep codebase knowledge, reducing onboarding time and supervision overhead while ensuring consistent, correct execution.

How do implementation plans enforce code quality standards?

Implementation plans enforce DRY (Don't Repeat Yourself), YAGNI (You Aren't Gonna Need It), and TDD (Test-Driven Development) principles throughout task definitions. Each task includes test specifications and verification commands, ensuring code quality from the start rather than requiring post-implementation review cycles.

What's the difference between implementation plans and basic task lists?

Implementation plans go beyond task lists by providing exact file paths, complete code blocks ready to copy, test definitions, and verification commands. Basic lists state what to do; implementation plans show exactly how to do it, where to do it, and how to verify it worked—eliminating guesswork for engineers unfamiliar with the codebase.

Related Skills