prepare-execution-plan

Decompose high-level delivery plans into file-level execution sequences with test checkpoints.

157|28|Updated Feb 7, 2026
One-click install
npx skills add https://github.com/Fr-e-d/GAAI-framework --skill prepare-execution-plan-fr-e-d
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: prepare-execution-plan
Source: https://github.com/Fr-e-d/GAAI-framework/tree/main/.gaai/core/skills/delivery/prepare-execution-plan
Command: npx skills add https://github.com/Fr-e-d/GAAI-framework --skill prepare-execution-plan-fr-e-d

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill transforms a high-level delivery plan into a detailed, file-level execution sequence, ensuring complex tasks are broken down logically and safely before implementation begins.

Core Features & Use Cases

  • Detailed Sequencing: Orders implementation steps to minimize broken states and manage dependencies.
  • Edge Case Enumeration: Identifies and maps edge cases and error paths to specific test checkpoints.
  • Risk Identification: Surfaces ambiguities and potential risks in the implementation process.
  • Use Case: For a Story involving changes to both a database schema and multiple API endpoints, this Skill would generate a precise order of operations, specifying which files to touch at each step and when to run integration tests.

Quick Start

Use the prepare-execution-plan skill to break down the high-level plan for story 'STORY-123'.

Frequently Asked Questions about prepare-execution-plan

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

FAQPage Schema
How do I decompose a high-level delivery plan into file-level execution steps?

To decompose a delivery plan, break complex Stories into a precise execution sequence mapping dependencies, identifying shared state, and specifying exact files to touch. This minimizes broken states during implementation.

What is the best way to manage dependencies and edge cases in a multi-phase software engineering plan?

Manage dependencies and edge cases by explicitly enumerating them and mapping error paths to specific test checkpoints. This creates an auditable, governed implementation sequence for complex Stories.

When do I need to create a detailed execution plan before implementation begins?

You need detailed execution planning for complex or multi-phase Stories involving shared state changes, like simultaneous database schema and API updates, ensuring safe ordering before implementation begins.

How do I sequence implementation steps to minimize broken states during software delivery?

Sequence implementation steps by mapping dependencies and shared state to order operations logically, like specifying when to run integration tests between file-level changes, minimizing broken states.

Does this task decomposition approach work for stories involving database schema and API changes?

Yes, task decomposition generates a precise order of operations for database schema and API changes, specifying which files to touch and when to run integration tests to manage risks safely.