Code

Refactor Plan + Safety Net (Incremental Steps + Tests)

Feature

What does this prompt do?

Turns a messy module into a staged refactor plan that preserves behavior. It identifies seams, proposes an incremental sequence of changes with checkpoints, defines the tests and characterization coverage needed to prevent regressions, and includes rollback/feature-flag guidance for safe delivery. Best for legacy code, large components, and “we need to clean this up without breaking prod”.

The Prompt

Act as a [enter your role].

Description:
[enter your description]

Refactor context:
- Code area/module:
- Current problems (complexity, duplication, bugs, performance, DX):
- Must keep behavior the same? (yes/no + exceptions)
- Constraints (timeline, no big rewrites, backwards compatibility, rollout rules):
- Target quality goals (readability, testability, performance, architecture compliance):

Input:
- Code snippet(s) / file(s) / architecture notes:
[paste here]
- Current tests (if any) and known edge cases:
[paste here]

Rules:
- Do not ask me questions. If information is missing, state explicit assumptions and proceed.
- Do NOT propose a big-bang rewrite. Provide an incremental plan with verification at each step.
- Be specific: name functions/modules to extract, interfaces to introduce, and tests to add.

Task:
1) Refactor strategy (high-level)
   - Identify seams and boundaries
   - Decide refactor pattern(s) (strangler, extract module, adapter, etc.)

2) Step-by-step plan (incremental)
   For each step include:
   - Goal
   - Exact changes (what to move/extract/rename)
   - Verification (tests to run/add, observable behavior)
   - Risk + rollback strategy

3) Test safety net
   - Characterization tests to lock behavior
   - New unit/integration tests (specific cases)
   - Coverage of edge cases and failure modes

4) Final state sketch
   - Intended module structure
   - Public interfaces and responsibilities

Output format:
Refactor Summary
Risks & Assumptions
Incremental Plan (Steps 1..N)
Test Safety Net
Final Target Structure
Copied to clipboard!

How to Use This Prompt

  1. Copy the prompt using the button above
  2. Open your preferred AI tool (ChatGPT, Claude, etc.)
  3. Paste the prompt and customize as needed
  4. Add specific steps in the WordPress editor for better guidance

Related Prompts

CODE
code-review

PR Review + Fix Plan (Concrete Edits + Tests)

Reviews a code change like a senior engineer before merge. It finds correctness issues, edge cases, API contract problems, performance pitfalls, and security/privacy risks, then outputs an ordered fix plan with concrete code edits (pseudo diff), a targeted test plan, and a safe rollout and monitoring checklist. The “assumptions and proceed” rule keeps it moving even if context is incomplete, while staying specific and implementation ready.

Zero-shot Role-based Structured-output Analytical
CODE
Bug debugging

Bug Triage & Fix Plan (5 Approaches + Ranking)

It guides the model to triage and resolve a bug with a structured, evidence-driven workflow. It produces exactly five distinct investigation and mitigation approaches, each with a clear hypothesis, the precise system areas to inspect, the specific logs/metrics/traces or SQL to collect, and an ordered checklist to confirm or falsify the hypothesis. It then ranks the approaches by fastest path to high-confidence resolution (including blast-radius and data-integrity risk) and performs a second-pass cross-comparison with scenario playbooks (e.g., PROD outage, data corruption risk, flaky issues) to refine the recommended path and output the first 10 concrete actions. By forcing explicit assumptions when context is incomplete, it reduces guesswork and lowers hallucination risk while keeping the plan executable.

Zero-shot Role-based Structured-output Analytical
CODE

Feature devlopment Blueprint (5 Approaches + Ranking)

It forces the model to produce an implementation-ready plan for a feature by generating exactly five distinct approaches, each with concrete architecture, code structure, and database design (including keys and indexes). It then ranks the approaches with explicit trade-offs and risks and runs a second-pass cross-comparison to refine the final recommendation under different scenarios. The “state assumptions and proceed” rule reduces vague back-and-forth and makes uncertainty explicit, which lowers hallucination risk and pushes the output toward actionable, verifiable engineering decisions.

Zero-shot Role-based Structured-output Analytical