| name | opusplan |
| description | Call `claude -p --model opus` to produce an execution-ready plan via the Claude Code CLI. Uses cloud Opus (separate billing) with a system prompt optimized for plans that guide local execution end-to-end. Trigger phrases — "/opusplan", "opus plan via claude", "plan with claude opus". |
| category | execution |
| runtimes | ["claude"] |
| pii_safe | true |
/opusplan — Execution plan via claude -p --model opus
Calls the local claude CLI in plan mode with Opus, producing a structured implementation plan designed to guide an executor (main Claude or /pdo) through end-to-end success. Uses cloud Opus — separate billing from the current session.
When to use vs alternatives
| Skill | Planner | Use when |
|---|
/opusplan | claude -p --model opus (external CLI) | Want cloud Opus reasoning but the plan is for a different machine or future session; no current-session context is needed |
/oplan | main Claude (this session) | You're already in a Claude Code session and want full repo context available during planning |
/cplan | claude -p (default: opus) with /plan skill | Frontend/UI planning or default cplan flow |
/pplan | local PI + Ollama | Sensitive plans, no cloud needed |
Flow
When user invokes /opusplan <topic>:
1. Build the brief
You are an execution-focused planner. Produce a plan that any capable coding agent can follow step by step without needing to ask clarifying questions.
## Output rules
- Every phase has exactly one "Verification" bullet with a concrete, executable command or test.
- Every file change cites the exact path and what changes (not "add feature", but "add `fetchUsers` in src/api/users.ts:45").
- Commands must be copy-paste runnable (include the full path, flags, expected args).
- If a step depends on a prior step's output, state the dependency explicitly.
## Structure (follow exactly)
```markdown
---
topic: <short topic>
generated_by: opusplan (claude -p --model opus)
generated_at: <ISO timestamp>
---
# <Topic>
## Goal
<one sentence describing the successful end state>
## Prerequisites
- <thing that must exist before starting; commands to verify>
## Phases
### Phase 1: <name>
**Goal**: <what this phase leaves in a working state>
- [ ] Step 1 — <exact action with file path and line numbers>
- **Verify**: `<command to run>`
- [ ] Step 2 — <exact action>
- **Verify**: `<command>`
### Phase 2: <name>
**Goal**: <what this phase leaves in a working state>
- [ ] Step 2.1 — ...
...
## Files changed (full inventory)
| File | Action | What changes |
|---|---|---|
| `/abs/path/file.py` | MODIFY | <specific lines/signatures> |
## Files created
| File | Purpose |
|---|---|
| `/abs/path/new.py` | <1 sentence> |
## Risks & gotchas
- `<risk>` — `<mitigation or workaround>`
## Open questions
- <anything the planner could not fully resolve>
## End-to-end verification
<the full command sequence to run after all phases are done, proving the work works>
## Next action
<first concrete step to take right now>
Keep the plan narrow: each phase should be completable in one sustained coding session (under ~15 minutes of active typing). If the task is bigger, chain phases so each one leaves the repo in a working state.
If you do not know enough about the codebase to cite specific file paths, say so in Open questions rather than guessing.
```
2. Invoke claude -p --model opus
Check that the claude CLI exists on PATH. If not, fall back to /oplan (current session Opus) and tell the user:
[opusplan: `claude` CLI not found — falling back to /oplan (current session)]
Build and run:
claude -p --model opus "$(cat $BRIEF_FILE)"
Use timeout with a generous budget: 1800s (30 min). Opus planning can take time for complex tasks.
3. Validate the output
Reject and warn if the plan:
- Is missing required sections (Goal, Phases with Verification, Files changed, End-to-end verification)
- Is < 500 chars or looks truncated mid-sentence
- Has no concrete file paths (all generic)
- Has phases without Verification bullets
4. Save the plan
Default: ./plans/opusplan-<slug>-<YYYYMMDD-HHMM>.md (auto-mkdir).
Wrap with frontmatter:
---
topic: <topic>
generated_by: opusplan (claude -p --model opus)
generated_at: <ISO timestamp>
duration_s: <elapsed seconds>
---
<claude output>
5. Present to user
[opusplan: <duration>s, plan saved to: <path>, phases: <N>]
**Goal**: <one sentence>
**Files**: <N> changed, <M> created
Next action: <quote from plan's "Next action" section>
Run this now? (y/n)
Flags
/opusplan <topic> full plan, save to ./plans/
/opusplan --timeout 600 <topic> custom timeout (seconds)
/opusplan --output <path> <topic> custom save path
/opusplan --no-save <topic> print plan only, don't save to file
Examples
Good fit
/opusplan add CSV export to the kanban CLI — output should mirror existing JSON exporter
Good fit
/opusplan refactor <PRODUCT_NAME> ES query builder to support nested boolean expressions
BAD fit
/opusplan fix the typo in README
→ Refuse. Tell user: just edit it directly, don't waste a planning round.
When claude CLI is unavailable
If the claude binary isn't found on PATH:
- Try common install locations (
~/.npm-global/bin/claude, /usr/local/bin/claude)
- If still not found, fall back to
/oplan and tell the user
Related
/oplan — same flow but using current session's Claude (full repo context available)/cplan — generic claude -p wrapper with /plan skill system prompt/pdo — execute an opusplan-saved plan locally with PI + Ollama/pplan — local-only planning via PI + Ollama (no cloud billing)
