Handoff Plan
Turn session handoffs into executable plans: capture full session data first, then write a phased implementation plan the next session can start coding from immediately.
Evidence shows the skill writes files, runs git commits, and invokes external tools (bd) with automated commit-and-close behavior; rollback requirements and naming rules are explicit, data flow is reasonably transparent, MIT license and attribution present. Deducted for: no explicit user confirmation gate before committing/closing, dependent /handoff skill not fully visible in scope, undeclared permission boundaries and sensitive-data handling.
Instructions are self-consistent with line-count checkpoints and rollback rules. Deducted for: undefined failure paths for the /handoff dependency and bd/beads tooling; thin failure feedback if tools are missing; static review cannot reproduce key paths, capping at the anchor of 10.
Scenario is clear (session handoff + executable plan), triggers are specific, output format well defined. Deducted for: no declared non-fit boundaries; core value depends on Claude Code and overseas services (GitHub, Beads, OpenViking) with no note on mainland-China reachability or Chinese-language support.
Well-layered instructions and a licensed repo with README. Deducted for: no per-skill version, changelog, or known-limitations disclosure; maintenance/update path only implicit; hidden assumptions around optional beads/memory dependencies.
Claims phased plans directly executable by the next session with validation criteria and rollback, giving clear marginal value. Deducted for: README's A/B test claims lack inspectable raw data; static review cannot confirm outputs are directly usable, capped at 7.
Auditable source files, README documentation, and license allow cross-checking structure claims. Deducted for: effectiveness claims rest on author assertions only, with no third-party execution evidence or committed tests; capped at 5 in static review.
- The skill writes files and runs git commits automatically; ensure no unrelated session changes exist before use.
- Depends on the /handoff skill and optional external tools (bd/beads, OpenViking); degradation when absent is undefined and may abort or produce incomplete plans.
- Core ecosystem is Claude Code with GitHub-hosted services; mainland-China users should assess network reachability; Chinese-language support is undeclared.
- No skill-level version or changelog; behavior changes across updates cannot be determined.
- Effectiveness data (A/B testing) is author-asserted and independently unverified.
What does this skill do, and when should you use it?
handoffplan is the second skill in the REMvisual/claude-handoff repository, designed to run alongside /handoff. It first executes the full /handoff process (including its mandatory two-phase write) to produce a thorough handoff data file, then writes a matching PLAN_ file in the same directory that references — never duplicates — the handoff data. The plan includes a problem statement, key findings, anti-goals, per-phase steps with rollback strategies, and measurable success criteria. It also creates dependency-linked tasks via beads, commits the session's work, and outputs a paste prompt so the next session starts executing Phase 1 with clean full context, no exploration needed.
1) Runs the /handoff skill to create HANDOFF_{chain_tag}_{slug}_{date}.md, including the mandatory Phase 2 (read back, scan for uncaptured data, expand toward line minimums: Quick 150/250, Deep 300, Chunked 500; ceiling 800 lines); 2) After a line-count checkpoint, writes the paired PLAN_ file (120-250 lines, 2-5 phases) with goals, evidence links, anti-goals, file lists, validation commands, rollback plans, and a Quick Start; 3) Creates beads per phase via bd create with dependencies via bd dep add; 4) Persists state via bd remember if available; 5) Reports file paths, line counts, and the first action; 6) Surgically commits session files with a formatted message and outputs a ready-to-paste execution prompt for the next session. It never uses Claude Code's built-in plan mode because it writes files directly.
- A developer wrapping up a research session: direction is found, ready to build, and wants the next session to execute rather than explore
- Multi-day feature development: so the third or fourth session picks up from the agreed approach without re-discovering context
- Teams using beads for issue tracking: each implementation phase automatically becomes a tracked task with dependency chains
- Users hit by context compaction: chained handoff files let fresh sessions restore full context by reading files
- Projects where failed approaches must not be repeated: 'What We Tried' and Anti-Goals explicitly block known-dead routes
What are this skill's strengths and limitations?
- Plans reference the handoff instead of duplicating it, and every phase must trace back to evidence
- Anti-Goals explicitly exclude approaches already proven to fail, preventing repeated dead ends
- Every phase mandates a rollback strategy and success criteria tied to baseline numbers
- Automatically creates dependency-linked tasks and uses paired naming (HANDOFF_*/PLAN_* same slug) so cleanup tools can find both files
- The paste prompt is execution-oriented: the next session does not onboard, explore, or ask questions
- Hard dependency on the /handoff skill: the whole flow breaks without it; they must be installed as a pair
- Heavyweight: full two-phase handoff + plan + tasks + commit — overkill if you just want to pause a session quickly
- Explicitly forbids Claude Code plan mode, writes files directly, and commits to git automatically — requires trust in its auto-commit behavior
- Line minimums (e.g. 500 for Chunked) may incentivize padded, verbose handoff files
- The README's A/B testing claims are self-reported with no independent validation; no automated test suite is provided
- Beads integration is a soft 'if available' dependency; exact fallback behavior without bd is not fully documented in the source
How do you install this skill?
Clone https://github.com/REMvisual/claude-handoff, then:
git clone https://github.com/REMvisual/claude-handoff.git
cp -r claude-handoff/skills/handoff ~/.claude/skills/
cp -r claude-handoff/skills/handoffplan ~/.claude/skills/
Note: this skill depends on the /handoff skill — install both. Verify by typing /handoff in Claude Code; it should appear in autocomplete. Task tracking defaults to bd (beads); the source does not fully document behavior when bd is absent.
How do you use this skill?
At the end of a session, ready to implement, type:
/handoffplan optionally followed by context about what to plan (a soft hint for the problem statement and phasing)
The skill handles the handoff, plan, tasks, and commit automatically, then outputs a paste prompt. Paste it into a fresh session, which reads the plan and handoff, claims Phase 1, and starts coding. Natural-language triggers also work: 'handoff with a plan', 'make this into a plan', 'plan this out', etc.
How does this skill compare with similar options?
It is a sibling of /handoff in the same repo: /handoff suits pausing mid-research — the next session reads the handoff and onboards/explores; /handoffplan suits post-research implementation — the next session reads the plan and starts coding Phase 1. The author also positions it against Claude Code's built-in compaction summaries, arguing those lack chain tracking, self-validation, and evidence mining. Tools like OpenViking (persistent memory) are complementary, not competitors.