breakdown-epic-arch

Decompose large architectural commands into phased execution plans with dependency analysis.

Updated Aug 27, 2026
One-click install
npx skills add https://github.com/msageha/maestro_v2 --skill breakdown-epic-arch
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: breakdown-epic-arch
Source: https://github.com/msageha/maestro_v2/tree/main/templates/skills/planner/breakdown-epic-arch
Command: npx skills add https://github.com/msageha/maestro_v2 --skill breakdown-epic-arch

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses the complexity of breaking down large, multi-component architectural changes into manageable, safe, and executable tasks, ensuring dependencies are respected and changes are rolled out systematically.

Core Features & Use Cases

  • Architectural Decomposition: Safely breaks down large commands that span multiple layers and components based on dependency analysis.
  • Phased Execution: Organizes tasks into 'Concrete' (immediately executable) and 'Deferred' (dependent on previous phases) stages.
  • Wave Grouping: Groups parallelizable tasks within phases into 'Waves' for efficient execution.
  • Persona Delegation: Defines a clear sequence of personas (researcher, architect, implementer, QA) for progressive task handling.
  • Use Case: When planning a major refactor of a microservice that affects the database, API, and frontend, this Skill helps define the precise order of operations, from schema changes to API updates, ensuring a smooth transition.

Quick Start

Use the breakdown-epic-arch skill to decompose the task of refactoring the user authentication module.

Frequently Asked Questions about breakdown-epic-arch

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

FAQPage Schema
How do I break down a large architectural refactor into safe execution phases?

Break down architectural refactors by decomposing multi-layer commands into Concrete and Deferred stages based on dependency analysis. This phased execution plan organizes tasks into parallelizable waves to ensure systematic and safe rollouts across affected components.

What is the best way to manage dependencies when planning a multi-component system upgrade?

Manage dependencies during system upgrades by grouping parallelizable tasks into sequential execution waves. This ensures that foundational changes are completed before deferred tasks begin, preventing integration failures across architectural layers.

How does phased task decomposition handle complex software feature rollouts?

Phased task decomposition handles feature rollouts by separating immediately executable tasks from deferred ones. It applies dependency management to define a precise order of operations, ensuring smooth transitions across database, API, and frontend layers.

Can I use persona-based delegation for microservice refactoring tasks?

Yes, you can use persona-based delegation for microservice refactoring by assigning progressive task handling to specific roles. The execution plan sequences personas like researcher, architect, implementer, and QA to ensure structured development.

When do I need architectural decomposition for a software project?

You need architectural decomposition when planning large-scale changes that span multiple components and layers, such as major refactors or system upgrades. It ensures dependencies are respected and changes are rolled out systematically.