# super-plan-mode

Adopt this skill: https://proskills.md/skills/other/temikeezy-super-plan-mode-skills-super-plan-mode

Page: https://proskills.md/skills/other/temikeezy-super-plan-mode-skills-super-plan-mode
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/super-plan-mode/SKILL.md
size: 5773
upstream: https://github.com/temikeezy/super-plan-mode/blob/main/skills/super-plan-mode/SKILL.md

````text
---
name: super-plan-mode
description: 'This skill should be used only when the user explicitly mentions "super plan mode", "spm", "use super plan", "run super plan mode", "activate super plan", or directly invokes /super-plan-mode or /spm. Do NOT trigger for generic planning phrases like "plan this", "show me the plan", "think through the approach", or "plan before coding" — those should be handled by the agent''s built-in plan mode.'
license: MIT
metadata:
  author: temikeezy
  version: "1.0.0"
  organization: openclaw
  date: March 2026
  abstract: A universal agent skill for structured plan mode. Built natively for OpenClaw and Claude Code. Generates a rich implementation plan — with affected files, confidence-scored steps, risk matrix, effort estimate, and alternative approaches — then halts execution at a numbered acceptance gate until the user explicitly approves. Also compatible with Cursor Agent, Windsurf, Codex CLI, Aider, and any AI coding agent.
---

# Super Plan Mode Skill

This skill activates Super Plan Mode: a structured planning workflow that generates a rich implementation plan and halts for explicit user approval before any code changes are made.

## Behavior When Active

When this skill is active:

1. DO NOT create, edit, or delete any files until the user has explicitly approved the plan.
2. Announce plan mode immediately: "Entering super plan mode. I will generate a plan and wait for your approval before making any changes."
3. Run the full planning workflow described below.
4. Present the numbered acceptance gate and wait.

## Compatibility

This skill works in any agent environment — Claude Code, Codex CLI, Cursor Agent, Windsurf, Aider, or any text-based AI coding assistant. See `references/agent-compat.md` for environment-specific notes.

## Planning Workflow

### Step 1: Clarify (if needed)

If the request is ambiguous, ask 1–3 focused questions before exploring. If the request is clear, proceed directly to exploration.

Do not ask more than 3 questions in a single message. Start with the most important.

### Step 2: Explore the Codebase (Read-Only)

**If subagents are supported (OpenClaw, Claude Code, Cursor Agent, Windsurf Cascade, Codex CLI):**
Launch 2–3 `plan-researcher` agents in parallel, each with a distinct focus:
- Agent A: architecture mapping and existing patterns
- Agent B: affected files and dependency tracing
- Agent C: risks, uncommitted changes, and fragile areas

After agents return, read all files they identify as critical.

**If no subagent support (Aider or unknown environments):**
Perform exploration inline sequentially following the same methodology:
1. Map architecture and patterns (Glob, Grep, Read)
2. Trace affected files and dependencies
3. Assess risks — run `git status` and `git log --oneline -10`

In both cases: read critical files, understand existing patterns, and identify risks before generating the plan.

### Step 3: Generate the Plan

Produce the plan document following the format in `references/plan-template.md` exactly.

**Before generating, check for `.super-plan-mode.json`** in the project root. If present, read it and apply its defaults (planSaveDir, autoPhaseCheckpoints, etc.).

Save the plan to: `[planSaveDir]/super-plan-mode-[unix-timestamp].md`
Default save location: `.claude/plans/super-plan-mode-[timestamp].md`

**MANDATORY: After saving, output this line verbatim (with the actual path filled in):**
```
📁 Plan saved to: `.claude/plans/super-plan-mode-[timestamp].md`
```
This must appear before the acceptance gate. Never skip it.

### Step 4: Present the Acceptance Gate

**STOP. After presenting the plan and the save location, you MUST output the gate below. Do NOT proceed to implementation, do NOT write any files, do NOT take any action until the user selects an option.**

Output the numbered menu exactly as follows:

```
────────────────────────────────────────────
  Plan ready. What would you like to do?

  1  Accept & Build
  2  Reject / Cancel
  3  Modify plan
  4  Accept Phase 1 only  ← (shown only for L/XL estimates)
────────────────────────────────────────────
  Enter number (or type the action):
```

**HALT HERE. Do not write a single file or run any command until the user replies.**

Response handling — execute immediately upon receipt:
- **1 / "accept" / "build" / "yes" / "y"** → proceed to implementation (Step 5)
- **2 / "reject" / "cancel" / "no" / "n"** → acknowledge, summarize useful research findings, stop; do not modify any files
- **3 / "modify" / "m"** → ask what to change, revise the plan, show a diff of changed sections, re-present gate
- **4 / "phase 1" / "p1"** → implement only Phase 1 steps, then pause and re-present gate for remaining phases

### Step 5: Implement (ONLY After User Selects Option 1 or Option 4)

**Do not begin this step unless the user replied "1", "accept", "build", "yes", "y", "4", "phase 1", or "p1" to the gate.**

Execute plan steps in order. For L/XL estimates with phases: after each phase completes, pause and report:
- What was completed
- What comes next
- Any unexpected findings that may affect the remaining plan

Ask the user to confirm before starting the next phase.

On full completion, summarize: files created/modified, steps completed, deviations from plan (if any), suggested next steps.

## Additional Resources

- **`references/plan-template.md`** — canonical plan output format with all required sections
- **`references/agent-compat.md`** — per-agent environment notes for exploration, gate behavior, model flags, and plan file handling
````

## File: README.md
upstream: https://github.com/temikeezy/super-plan-mode/blob/main/README.md

````text
```
 ███████╗██╗   ██╗██████╗ ███████╗██████╗
 ██╔════╝██║   ██║██╔══██╗██╔════╝██╔══██╗
 ███████╗██║   ██║██████╔╝█████╗  ██████╔╝
 ╚════██║██║   ██║██╔═══╝ ██╔══╝  ██╔══██╗
 ███████║╚██████╔╝██║     ███████╗██║  ██║
 ╚══════╝ ╚═════╝ ╚═╝     ╚══════╝╚═╝  ╚═╝

 ██████╗ ██╗      █████╗ ███╗   ██╗    ███╗   ███╗ ██████╗ ██████╗ ███████╗
 ██╔══██╗██║     ██╔══██╗████╗  ██║    ████╗ ████║██╔═══██╗██╔══██╗██╔════╝
 ██████╔╝██║     ███████║██╔██╗ ██║    ██╔████╔██║██║   ██║██║  ██║█████╗
 ██╔═══╝ ██║     ██╔══██║██║╚██╗██║    ██║╚██╔╝██║██║   ██║██║  ██║██╔══╝
 ██║     ███████╗██║  ██║██║ ╚████║    ██║ ╚═╝ ██║╚██████╔╝██████╔╝███████╗
 ╚═╝     ╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝   ╚═╝     ╚═╝ ╚═════╝ ╚═════╝ ╚══════╝
```

<div align="center">

**Plan first. Build with confidence.**

*Built natively for [OpenClaw](https://openclaw.dev) and [Claude Code](https://claude.ai/code) · Works with Cursor, Windsurf, Codex CLI, Aider, and more.*

[![Version](https://img.shields.io/badge/version-1.0.0-blue.svg)](https://github.com/temikeezy/super-plan-mode)
[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
[![OpenClaw Native](https://img.shields.io/badge/OpenClaw-Native-orange.svg)](https://openclaw.dev)
[![Claude Code](https://img.shields.io/badge/Claude%20Code-Native-blueviolet.svg)](https://claude.ai/code)
[![Agent Skills Standard](https://img.shields.io/badge/Agent%20Skills-Open%20Standard-brightgreen.svg)](https://agentskills.io)

</div>

---

## What It Is

**Super Plan Mode** is a universal agent skill that generates a rich implementation plan and **halts until you explicitly approve it** before writing a single line of code.

Built natively for [OpenClaw](https://openclaw.dev) and [Claude Code](https://claude.ai/code) following the [Agent Skills Open Standard](https://agentskills.io). Compatible with any AI coding agent — Cursor, Windsurf, Codex CLI, Aider, and more.

No passive guardrails. No soft suggestions. A hard stop, a structured plan document, and a numbered menu waiting for your decision.

---

## Features

- 🛑 **Explicit accept/build gate** — numbered menu halts execution; nothing runs until you say so
- 📋 **Rich plan artifacts** — problem statement, affected files, implementation steps, risk matrix, effort estimate, acceptance criteria, rollback notes, and alternative approaches — all in one saved document
- 🟢🟡🔴 **Confidence scores** — every implementation step rated by how well-understood it is based on codebase exploration
- 🔍 **Parallel codebase exploration** — multiple read-only agents research architecture, affected files, and risks simultaneously (supported in OpenClaw, Claude Code, Cursor 2.4+, Windsurf Wave 13+, and Codex CLI)
- ⚠️ **Pre-flight checks** — warns if uncommitted changes overlap with the plan before you accept
- 🔁 **Modify loop** — type `3` to revise the plan; see a diff of what changed before re-approving
- 💾 **Plan persistence** — plans saved to `.claude/plans/` for reference, sharing, and resuming
- ▶️ **Resume saved plans** — `--resume <file>` loads a past plan and jumps straight to the gate
- 📁 **Plan history** — `--list` shows all saved plans for the current project
- 🌐 **Multi-agent compatible** — works across Claude Code, Codex CLI, Cursor Agent, Windsurf, and Aider
- 🤖 **Model + provider flag** — `--model provider/model` lets you choose the implementation model from any provider
- 💨 **Dry-run mode** — `--dry-run` generates and saves the plan without offering to execute
- ⚡ **Process optimized** — parallel agents with narrow, non-overlapping scopes; structured output keeps results focused
- ⚙️ **Project config** — `.super-plan-mode.json` sets per-project defaults for save path and checkpoints

---

## Quick Start

```bash
# Full plan → gate → build workflow
/super-plan-mode add OAuth login with Google and GitHub

# Shorthand alias (same thing)
/spm add a payment webhook handler

# Generate plan only, build later
/spm --dry-run refactor the auth middleware

# Resume a saved plan
/spm --resume .claude/plans/super-plan-mode-1234567890.md

# List all saved plans
/spm --list

# Choose implementation model
/spm --model provider/model add a caching layer
```

Or trigger passively — just tell the agent:

> "Let's plan this before writing any code"
> "Show me the plan first"
> "Don't touch anything yet, just plan it out"

---

## How It Works

### Phase 1 — Understand

Clarifies the request. Asks focused questions if anything is ambiguous. Confirms understanding before moving on.

### Phase 2 — Explore (Read-Only)

Launches parallel explore agents (where supported) to map the codebase from three angles:

- **Architecture** — patterns, conventions, existing similar features
- **Affected Files** — what changes, what depends on it, blast radius
- **Risk / Conflicts** — uncommitted changes, fragile files, recent churn

In single-agent environments (Cursor, Codex, Windsurf, Aider), the same research runs inline sequentially. Same result either way.

### Phase 3 — Generate Plan

Produces a complete plan document and saves it to `.claude/plans/`. The plan includes:

| Section | Description |
|---------|-------------|
| Problem Statement | What's broken or missing |
| Goal | Verifiable outcome |
| Affected Files | Every file, change type, and reason |
| Implementation Steps | Ordered steps with confidence scores |
| Risk Assessment | Overall rating + risk matrix |
| Effort Estimate | S / M / L / XL with reasoning |
| Acceptance Criteria | Testable checklist |
| Rollback Notes | How to undo (required for Medium/High risk) |
| Alternative Approaches | At least one alternative with trade-offs |
| Phases | Checkpoints for Large/XL work |

### Phase 4 — The Gate

Pre-flight checks run first (uncommitted file conflicts, test command detection). Then the plan is presented with this menu:

```
────────────────────────────────────────────
  Plan ready. What would you like to do?

  1  Accept & Build
  2  Reject / Cancel
  3  Modify plan
  4  Accept Phase 1 only  ← (large plans only)
────────────────────────────────────────────
  Enter number (or type the action):
```

**Nothing happens until you respond.** Type `3` to iterate; see what changed in the plan before re-approving. Type `2` to cancel cleanly.

### Phase 5 — Implementation

Executes the approved plan step by step. For Large/XL plans, pauses at each phase checkpoint to report progress and confirm continuation. Ends with a summary of everything that changed.

---

## Confidence Scores

Every implementation step is rated based on how thoroughly it was understood during exploration:

| Score | Meaning |
|-------|---------|
| 🟢 High | Well-understood. Clear file paths, existing patterns to follow. |
| 🟡 Medium | Some uncertainty. May need additional discovery mid-implementation. |
| 🔴 Low | Significant unknowns. Review carefully before accepting. |

---

## Model Flag

Use `--model provider/model` to specify which model runs the implementation. Omit it to use whatever your environment has active. Any `provider/model` value is accepted as passthrough — ensure your environment is configured for the model you want to use.

---

## Project Config

Add `.super-plan-mode.json` to your project root to set defaults:

```json
{
  "planSaveDir": ".claude/plans",
  "autoPhaseCheckpoints": true,
  "preflightChecks": true
}
```

CLI flags always override config file values.

---

## Works With

| Agent | Support | Subagents | Gate |
|-------|---------|-----------|------|
| **OpenClaw** ⭐ | Native skill (agentskills.io) | ✅ Parallel | Numbered menu |
| **Claude Code** ⭐ | Native plugin | ✅ Parallel | Numbered menu |
| **Cursor Agent** | Compatible (v2.4+) | ✅ Parallel + async | Numbered menu |
| **Windsurf (Cascade)** | Compatible (Wave 13+) | ✅ Parallel (5 agents) | Numbered menu |
| **Codex CLI** | Compatible | ✅ Parallel (Agents SDK) | Numbered menu |
| **Aider** | Compatible | ➡️ Inline sequential | Numbered menu |

See `skills/plan-mode/references/agent-compat.md` for detailed per-a
````
