implementation-plan

Generate detailed execution plans for software feature implementation.

Updated Jun 26, 2025
One-click install
npx skills add https://github.com/flaviogragnolati/coco --skill implementation-plan-flaviogragnolati
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: implementation-plan
Source: https://github.com/flaviogragnolati/coco/tree/main/.agents/skills/implementation-plan
Command: npx skills add https://github.com/flaviogragnolati/coco --skill implementation-plan-flaviogragnolati

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill generates a concrete execution plan for developers or AI coding agents to implement features without redoing discovery.

Core Features & Use Cases

  • Concrete Execution Plan: Produces a detailed plan with objective, scope, non-goals, deferred items, assumptions, dependencies, and phased steps.
  • Mid-to-Low Level: Ensures tasks are specific enough to avoid ambiguity but abstract enough to allow implementation flexibility.
  • Codebase Integration: Grounds the plan in the real codebase, referencing existing patterns and avoiding hypothetical scenarios.

Quick Start

Generate an implementation plan for the feature 'user-cache' using the implementation-plan skill.

Frequently Asked Questions about implementation-plan

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

FAQPage Schema
How do I create an execution plan for feature implementation?

To create an execution plan for feature implementation, this Skill decomposes requirements into mid-to-low-level phased steps, defining objectives, scope, non-goals, and dependencies while grounding tasks in your real codebase patterns.

What is mid-to-low-level task decomposition in software development?

Mid-to-low-level task decomposition in software development breaks features into specific steps that avoid ambiguity while maintaining enough abstraction to allow flexible implementation execution by developers or AI coding agents.

How do I generate a codebase-integrated execution plan without redoing discovery?

Generating a codebase-integrated execution plan without redoing discovery requires analyzing existing documentation and real codebase patterns to produce concrete phased steps, avoiding hypothetical scenarios and ensuring accurate feature implementation.

Does this implementation planning approach work for AI coding agents?

Yes, this implementation planning approach works for AI coding agents by producing concrete execution plans with defined objectives, assumptions, and dependencies that provide sufficient detail for autonomous feature implementation.

What's the best way to structure an execution plan for complex software features?

The best way to structure an execution plan for complex software features is to include objective, scope, non-goals, deferred items, assumptions, dependencies, and phased steps grounded in real codebase analysis.

When should I not use mid-to-low-level task decomposition for feature implementation?

You should not use mid-to-low-level task decomposition when project direction is unknown, as this approach assumes direction is established and focuses on analyzing existing codebase and documentation to generate concrete execution steps.