code-create-staged-plan

Generate dependency-ordered staged plans for large codebase changes.

276|37|Updated Dec 5, 2025
One-click install
npx skills add https://github.com/open-thoughts/OpenThoughts-Agent --skill code-create-staged-plan
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: code-create-staged-plan
Source: https://github.com/open-thoughts/OpenThoughts-Agent/tree/main/.claude/skills/code-create-staged-plan
Command: npx skills add https://github.com/open-thoughts/OpenThoughts-Agent --skill code-create-staged-plan

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Design, scope, and sequence substantial codebase changes as a dependency-ordered staged plan, reducing risk and enabling staged execution.

Core Features & Use Cases

  • Parent plan document: a single source of truth for the change, including goals, scope, and evidence.
  • Per-stage scope docs: stage-specific gates and validation criteria that allow incremental delivery.
  • Evidence and breadcrumbs: keeps dated agent_logs and notes under notes/<codebase>/ for traceability.
  • Safety invariants: parity gates and flag-off byte-identical behavior to enable safe gating and revertibility.
  • Complementary tooling: pairs with code-execute-staged-plan for the execution phase.

Quick Start

Create a parent plan and corresponding stage scopes for a new codebase change on your feature branch.

Frequently Asked Questions about code-create-staged-plan

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

FAQPage Schema
How do I plan large codebase changes as staged steps to reduce risk?

To plan large codebase changes as staged steps, generate a dependency-ordered staged plan that includes a parent plan document, per-stage scope docs, global invariants, and safety considerations to enable incremental delivery and revertibility.

What is a dependency-ordered staged plan for multi-step code fixes?

A dependency-ordered staged plan sequences multi-step code fixes by creating a parent plan document and per-stage scope docs with parity gates and flag-off byte-identical behavior to ensure safe gating and traceability.

How do I scope refactors and feature ports across complex repositories?

Scope refactors and feature ports by generating per-stage scope docs with validation criteria, maintaining dated agent_logs under notes directories, and establishing a borrow-map to track dependencies across complex repositories.

Can I use staged planning for kernel and performance code changes?

Yes, staged planning applies to kernel and performance changes by enforcing safety invariants, parity gates, and go-no-go validation criteria within per-stage scope docs to ensure safe, incremental delivery.

What's the best way to maintain traceability during large code refactors?

Maintain traceability during large code refactors by keeping dated agent_logs and evidence breadcrumbs under notes/<codebase>/ directories alongside the parent plan document to ensure a single source of truth.

When do I need a parent plan document for code changes?

You need a parent plan document for code changes when sequencing substantial refactors, multi-step fixes with parity requirements, or feature ports to establish goals, scope, and evidence as a single source of truth.