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
How do you install this skill?
- 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.
- Shell / CLI
- Local filesystem
Claude Codethe companion /handoff skillgitbeads CLI (optional, for task tracking)OpenViking (optional, for memory recall)
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.
tmp="$(mktemp -d)"
git clone --depth 1 https://github.com/REMvisual/claude-handoff.git "$tmp"
mkdir -p ~/.claude/skills
cp -R "$tmp/skills/handoffplan" ~/.claude/skills/
rm -rf "$tmp"Generated from the source repository and skill path; it copies only this skill's folder. If the author's install steps above differ, follow those first. To scope it to one project, replace ~/.claude/skills with that project's .claude/skills.
How do you use this skill?
Once installed, send your agent any of these to trigger it:
- handoff with a plan
- make this into a plan
- plan this out
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.
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 does this skill compare with similar options?
Side by side with related skills; every score comes from the same FSRS standard.
| Skill | FS score | Stars | Last updated | License |
|---|---|---|---|---|
| Handoff Plan this page | 47 · Use with care | ★ 64 | 8d ago | MIT |
| Handoff — Session Handoff Skill for Claude Code | 52 · Use with care | ★ 64 | 8d ago | MIT |
| Subagent-Driven Development | 50 · Use with care | ★ 299k | 15d ago | MIT |
| Harness Creator: Harness Engineering for AI Coding Agents | 56 · Use with care | ★ 20k | 24d ago | MIT |
| Executing Plans | 54 · Use with care | ★ 299k | 15d ago | MIT |
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.
How did FollowSkills review this skill?
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.
Open a dimension to read why it scored that way
Evidence confidence：Low — Mostly static review, author material or a limited demo; useful for discovery, not high-risk decisions.
See the full review method →