writing-plans

Generate structured implementation plans with tasks, file paths, and tests.

11|Updated May 17, 2026
One-click install
npx skills add https://github.com/StarryCod/cogitum --skill writing-plans-starrycod
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: writing-plans
Source: https://github.com/StarryCod/cogitum/tree/main/cogitum/data/skills/software-development/writing-plans
Command: npx skills add https://github.com/StarryCod/cogitum --skill writing-plans-starrycod

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Planning complex work is error-prone when requirements are vague. This Skill generates structured, bite-sized implementation plans with explicit tasks, paths, and verification steps to speed up delivery and reduce ambiguity.

Core Features & Use Cases

  • Generate task-level plans for multi-step features, including file changes, tests, docs, and review criteria.
  • Provide exact file paths and minimal, testable code snippets to guide implementation.
  • Facilitate delegation to subagents or teammates with a repeatable, auditable workflow.

Quick Start

Create a detailed implementation plan for a feature: "Add user authentication" and request a task-by-task breakdown with file paths and tests.

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 complex software features into bite-sized implementation tasks?

Implementation plans break complex features into bite-sized tasks of 2-5 minutes each, specifying exact file paths, minimal code examples, and verification steps. This structured task-splitting translates vague requirements into concrete, actionable development steps for consistent execution.

How do I create implementation plans for cross-team handoffs?

Implementation plans for cross-team handoffs specify explicit file paths, testable code snippets, and verification steps aligned with TDD. This provides a repeatable, auditable workflow that reduces ambiguity when delegating complex features to teammates or subagents.

What's the best way to translate vague requirements into concrete development tasks?

Translating vague requirements requires generating structured implementation plans with task-level breakdowns, exact file paths, and minimal testable code snippets. This approach reduces planning errors and speeds up delivery by providing explicit verification steps and review criteria for each task.

Can I generate TDD-aligned task plans that include verification steps and documentation goals?

Yes, implementation plans can be generated with verification steps explicitly aligned with TDD and documentation goals. Each bite-sized task includes minimal yet complete code examples and exact file paths to ensure testable, verifiable development progress throughout the feature lifecycle.

Does this approach work for delegating multi-step features to subagents?

Yes, generating structured implementation plans facilitates delegation to subagents by providing a repeatable, auditable workflow. The plans specify bite-sized tasks, explicit file paths, and review criteria, enabling consistent execution across developers and automated agents for multi-step features.