writing-plans

Generate step-by-step implementation plans with file paths and code examples.

9|Updated Aug 12, 2025
One-click install
npx skills add https://github.com/shekohex/dotai --skill writing-plans-shekohex
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/shekohex/dotai/tree/main/skills/writing-plans
Command: npx skills add https://github.com/shekohex/dotai --skill writing-plans-shekohex

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses the challenge of translating high-level feature designs into actionable, step-by-step implementation tasks for engineers who may lack deep context of the codebase.

Core Features & Use Cases

  • Detailed Task Breakdown: Creates granular, bite-sized tasks suitable for TDD workflows.
  • Context-Free Instructions: Assumes minimal prior knowledge from the engineer, providing exact file paths, code examples, and verification steps.
  • Use Case: After a feature is designed, use this skill to generate a comprehensive plan that an engineer can follow to implement the feature from scratch, including writing tests, minimal code, and commit messages.

Quick Start

Use the writing-plans skill to create an implementation plan for the new user authentication feature.

Frequently Asked Questions about writing-plans

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

FAQPage Schema
How do I generate a step-by-step implementation plan from a feature design?

To generate an implementation plan, provide your high-level feature design. The skill breaks down features into granular, actionable tasks with exact file paths, complete code examples, and verification steps for engineers with zero codebase context.

What is the best way to break down software development tasks for TDD workflows?

Breaking down tasks for TDD workflows involves creating granular, bite-sized tasks that include writing tests, generating minimal code, and crafting commit messages. This approach ensures each implementation step is verifiable and adheres to TDD principles.

Can I create context-free implementation instructions for engineers unfamiliar with my codebase?

Yes, you can create context-free implementation instructions. The skill assumes minimal prior knowledge, providing exact file paths, complete code examples, and verification steps so an engineer can implement the feature from scratch without deep codebase context.

Does the generated implementation plan follow DRY and YAGNI principles?

The generated implementation plan strictly adheres to DRY and YAGNI principles. It provides exact file paths and complete code examples designed to prevent code duplication and avoid unnecessary features during the software development process.

How do I translate high-level designs into actionable coding tasks?

Translating high-level designs into actionable coding tasks requires breaking down features into step-by-step instructions. The skill generates exact file paths, code examples, and verification steps, facilitating efficient development from scratch without prior codebase knowledge.

What are the limitations of generating implementation plans without codebase access?

Generating implementation plans without codebase access relies on zero codebase context. While it provides exact file paths and complete code examples, engineers must manually verify each step against their actual environment to ensure the generated tasks align with existing code structures.