plan-flow

Analyze repository designs for duplicated structures and generate phased execution plans.

258|26|Updated Dec 9, 2025
One-click install
npx skills add https://github.com/majiayu000/spellbook --skill plan-flow
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: plan-flow
Source: https://github.com/majiayu000/spellbook/tree/main/skills/plan-flow
Command: npx skills add https://github.com/majiayu000/spellbook --skill plan-flow

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve?

Plan-flow helps teams identify duplicate or redundant designs in a codebase and converts those findings into a concrete, executable plan with traceable steps and tests.

Core Features & Use Cases

  • Surface repository architecture duplications and dead-end paths.
  • Generate a phased, testable execution plan with evidence, risk scoring, and clear ownership.
  • Enable a strict step-test-update loop to keep plans synchronized with changes.

Quick Start

Run the redundancy scan and invoke the plan generator to create a draft execution plan.

Frequently Asked Questions about plan-flow

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

FAQPage Schema
How do I identify duplicated or redundant structures across multiple files in a repository?

To identify redundant structures across multiple files, you can run a multi-file redundancy scan that surfaces architecture duplications and dead-end paths, converting those findings into a concrete execution plan with traceable steps.

How do I convert architecture gaps into an executable plan with testing loops?

Converting architecture gaps into an executable plan requires enforcing a step-test-update loop that generates phased execution schedules, ensuring changes remain synchronized with testable convergence and explicit evidence.

What is the best way to generate a phased execution plan with risk scoring for codebase refactoring?

Generating a phased execution plan with risk scoring involves analyzing repository designs to produce structured phases, enforcing guardrails, and requiring explicit evidence to ensure safe, testable convergence during refactoring.

Can I use phase scheduling to enforce a step-test-update loop for repository design analysis?

Yes, phase scheduling enforces a strict step-test-update loop during repository design analysis, requiring phase scoring and guardrails to keep plans synchronized with changes and ensure safe convergence.

Does redundancy analysis require explicit evidence and phase scoring to produce a structured plan?

Redundancy analysis requires explicit evidence and phase scoring to produce a structured plan, ensuring that identified architecture gaps are converted into safe, testable execution steps with clear ownership.

When should I not use automated redundancy scanning for architecture gap analysis?

Automated redundancy scanning requires explicit evidence and phase scoring to function correctly; you should avoid it when a repository lacks multi-file structures or when testable convergence cannot be enforced through guardrails.