By shihwesley
Structured planning for Claude Code with interactive decision gates. Walks through requirements gathering, approach selection, and plan validation before any code is written. Two modes: task-based (single plan file with sequential phases) for straightforward features, and spec-driven (multi-file specs with dependency DAG, topological sprint grouping, and two-level task tracking) for complex multi-domain work. Plans are categorized (feat/fix/refactor/review/test/polish/general) and stored in docs/plans/{category}/{name}/ for multi-plan coexistence. Auto-detects category from user input. Includes session recovery, multi-plan management, auto-detection of complex tasks, and checkpoint protocols for error escalation.
Based on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
A Claude Code plugin that turns complex tasks into structured plans before you write a line of code.
Two modes: task-based for straightforward features, spec-driven for multi-domain work with dependency tracking. Plans are categorized by type and stored in separate directories so multiple plans can coexist.
Workflow contract — planning now generates three additional files that bridge /interactive-planning and /orchestrate:
| File | Location | Purpose |
|---|---|---|
workflow.md | Plan directory | Declarative execution config: retry behavior, between-phase gates, Liquid-style prompt templates |
handoff.md | .claude/handoff.md | Fixed-size file (~100-150 lines) that each phase agent reads on start and overwrites on finish. The only communication channel between sequential phase runners. |
progress-log.md | .claude/progress-log.md | Append-only session history. Newest-first entries for human review. Phase agents never read this. |
Inspired by OpenAI's Symphony workflow contract pattern. The key idea: separate what the agent does (plan phases) from how phases get executed (retry, gates, prompts).
Gate 1 now asks project type (greenfield / brownfield / prototype). This feeds into workflow.md so phase agents know the development context.
Prompt templates — workflow.md includes a ## Phase Prompt and ## Continuation Prompt section with {{ variable }} placeholders. The orchestrator renders these per-phase, so each agent gets a tailored prompt with prior phase summaries, acceptance criteria, and workspace paths.
Continuation retries — when a phase fails, the orchestrator auto-retries with a continuation prompt that tells the agent "this is attempt #N, don't restart from scratch." Configurable via execution.max_phase_retries in workflow.md.
Between-phase gates — choose auto (proceed without asking), manual (confirm before each phase), or review (show diff summary then confirm). Set via execution.gates.between_phases in workflow.md.
Progress enforcement — strict mode validates that handoff.md was actually updated before a phase reports completion. Catches the stale-progress-file problem where code changes land but the tracking file doesn't get updated.
All changes are backward compatible. Existing plans without workflow.md work exactly as before.
Categorized plan directories — plans now live in docs/plans/{category}/{name}/ instead of a flat docs/plans/. Multiple planning sessions coexist without overwriting each other.
7 categories, auto-detected from your request:
| Category | Triggers on |
|---|---|
feat | New functionality (default) |
fix | Bugs, crashes, errors |
refactor | Restructuring, migrations |
review | Audits, evaluations |
test | Test strategy, coverage |
polish | UI/UX, performance, accessibility |
general | Whole-app architecture |
No extra gate question — the category is inferred from what you ask for. You can override via "Other" at Gate 1.
You: "Plan the authentication system"
→ Auto-detected: feat/auth-system
→ Directory: docs/plans/feat/auth-system/
You: "Fix the login crash on iOS 18"
→ Auto-detected: fix/login-crash-ios18
→ Directory: docs/plans/fix/login-crash-ios18/
Commands now target specific plans:
/interactive-planning resume feat/auth-system
/interactive-planning status fix/login-crash
/interactive-planning list
/orchestrate docs/plans/feat/auth-system works with zero config — the plan ingester finds manifest.md or task_plan.md in whatever directory you point it at.
Legacy plans (flat docs/plans/ or root-level files) are still detected and resumable.
Gate 5: Architecture Review — a mandatory review step between plan validation and execution. Before any code gets written, the plan is evaluated across 8 dimensions:
| Dimension | What it catches |
|---|---|
| System design & boundaries | Responsibility leaks, shotgun surgery |
| Dependency graph & coupling | Cascading changes, circular deps |
| Data flow & bottlenecks | Hot paths, unnecessary copies |
| Scaling & SPOFs | What breaks at 10x/100x |
| Security architecture | Auth gaps, leaky API surfaces |
| Error handling & failure modes | Recovery vs crash, graceful degradation |
| Testability | Hidden runtime deps, isolation problems |
| Existing codebase fit | Pattern conflicts, maintenance tax |
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimnpx claudepluginhub shihwesley/shihwesley-plugins --plugin interactive-planningResearch pipeline + sandboxed Python execution for Claude Code. Turns any topic into agent expertise: structured question tree → source discovery → zero-context fetch (content never enters LLM context) → .mv2 indexing → REPL-based distillation → compact expertise artifact. Also runs Python in isolated Docker containers for code execution, DSPy sub-agents, and data analysis.
Maps codebases of any size using parallel Sonnet subagents with Merkle-tree change detection. Generates docs/CODEBASE_MAP.md with architecture diagrams, module guides, data flows, and navigation guides. Creates docs/.mercator.json merkle manifest for O(1) staleness checks — compare a single root hash to know if anything changed. Post-commit hook auto-refreshes hashes in ~2 seconds with zero API tokens. Supports incremental updates: only re-explores changed modules. Works without git via pure hash-based diff.
Reverse engineer and extract capabilities from any source — repos, configs, binaries, articles — into your agent workflow. Security scanning, manifest tracking, cross-agent restore.
TLDR-aware code simplifier — uses AST summaries for context, full reads only for target files. 80%+ token savings on large codebases. Merkle-integrated for O(1) change detection when used with mercator-ai.
Ambient dev environment management — auto-switches between dev, test, staging, and prod using Docker containers, sidecars, and task-aware classification. Provides /orbit commands for explicit control.
Iterative plan review and execution workflow for Claude Code
AI-powered cascading development framework with design document system and multi-agent collaboration. Breaks down projects into Features (Mega Plan), Features into Stories (Hybrid Ralph), with auto-generated technical design docs, dependency-driven batch execution, Git Worktree isolation, and support for multiple AI agents (Codex, Amp, Aider, etc.).
Plan and autonomously build a software task end-to-end. Recons the codebase, applies preloaded memory, decomposes into the right number of phases, gets one confirmation, then prepares a single ready-to-paste /goal command — one paste between you and done — that drives execution to completion with built-in retry, fix-spec recovery, and per-phase memory writeback. Works on Claude Code and Codex.
Structured implementation planning, interactive annotation review, and autonomous plan execution
Upstash Context7 MCP server for up-to-date documentation lookup. Pull version-specific documentation and code examples directly from source repositories into your LLM context.
Comprehensive skill pack with 66 specialized skills for full-stack developers: 12 language experts (Python, TypeScript, Go, Rust, C++, Swift, Kotlin, C#, PHP, Java, SQL, JavaScript), 10 backend frameworks, 6 frontend/mobile, plus infrastructure, DevOps, security, and testing. Features progressive disclosure architecture for 50% faster loading.