planning-methodology

Transform requirements into reversible implementation plans with risk assessments.

Updated Jul 23, 2025
One-click install
npx skills add https://github.com/zonta99/realestate-frontend --skill planning-methodology-zonta99
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: planning-methodology
Source: https://github.com/zonta99/realestate-frontend/tree/main/.claude/skills/planning-methodology
Command: npx skills add https://github.com/zonta99/realestate-frontend --skill planning-methodology-zonta99

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill eliminates risky, complex, and irreversible implementations by enforcing a systematic methodology for creating surgical, minimal-change, and fully reversible development plans. It ensures clarity and safety before any code is written.

Core Features & Use Cases

  • Minimal Change Analysis: Identifies the smallest set of changes required, prioritizing extension over modification and new files over existing ones.
  • Comprehensive Risk & Rollback Planning: Assesses potential risks (breaking changes, performance, security) and creates detailed, executable rollback procedures for every change.
  • Use Case: When tasked with adding a new feature, this skill will generate a step-by-step plan that includes specific file changes, verification methods for each step, a full risk assessment, and a clear git revert command for immediate rollback if issues arise.

Quick Start

Create an implementation plan for adding Redis caching to the ProductService, focusing on minimal changes, clear verification, and a robust rollback strategy.

Frequently Asked Questions about planning-methodology

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

FAQPage Schema
How do I create a minimal-change implementation plan for a feature?

Minimal-change planning identifies the smallest set of code modifications needed by prioritizing file extension over modification and new files over existing ones. This approach reduces risk by limiting scope, making rollback simpler and verification faster. Start by analyzing your codebase structure, then decompose the feature into surgical changes with explicit verification steps for each.

What's the best way to plan reversible code changes?

Reversible planning enforces that every change includes an executable rollback procedure—typically a `git revert` command—before implementation begins. This ensures you can undo changes immediately if issues arise. The methodology assesses breaking changes, performance impact, and security risks upfront, then sequences changes to maintain system stability throughout.

How do I assess risk and plan rollback for development changes?

Risk assessment maps potential failures across breaking changes, performance degradation, and security exposure for each modification. Rollback planning creates step-by-step undo procedures tied to specific changes. Together they form a comprehensive contingency strategy, allowing developers to execute with confidence and respond quickly if verification detects problems.

Can I use this methodology for feature decomposition and architectural decisions?

Yes. This methodology applies to research-to-blueprint transitions, feature decomposition, and verification-driven planning. It enforces Simplicity, Minimal Changes, Reversibility, and Verification constraints, delivering a Codebase Profile, Minimal Change Strategy, Risk Assessment, and Implementation Sequence—suitable for both tactical changes and strategic architectural work.

When should I use surgical planning over standard development workflows?

Use surgical planning when changes must be auditable, reversible, or operate under strict safety constraints—critical systems, shared infrastructure, or high-stakes features. The methodology prevents complex, irreversible implementations by enforcing clarity and safety before code is written, reducing costly rework and production incidents.

What artifacts does minimal-change planning produce?

The methodology delivers four artifacts: a Codebase Profile (current state and dependencies), a Minimal Change Strategy (smallest required modifications), a Risk Assessment (potential failures and mitigation), and an Implementation Sequence (step-by-step execution order with verification methods and rollback commands).