Skip to content
cccskills
FreePublished on GitHub

handoff

Creates a compact handoff from verified work status, including commits, branches, automated checks, blockers, decisions, and the next action. Saves a durable record so another session or the user can resume without reconstructing the conversation.

OriginalShow the original description

Write a compact, decision-ready handoff so the next session (or the user) can continue without reconstructing the current one. Use when the session is ending, context is running low, the user asks for a handoff / 'pass the baton' / 'hand off', or a long-running operation needs a durable state checkpoint.

Works withGitHub
See how to install

Good for

  • Handing off work before ending a session
  • Moving ongoing work into a fresh conversation
  • Saving a checkpoint during a long operation
  • Preparing a short status handoff for the user

Files included (1)

  • SKILL.md4.7 KB

SKILL.md (original)

Review the instructions the agent will receive before you install.

Handoff

Write a compact, decision-ready handoff so the next session (or the user) can continue without reconstructing the current one. Use when the session is ending, context is running low, the user asks for a handoff / "pass the baton" / "hand off", or a long-running operation needs a durable state checkpoint. The goal: the durable artifact survives, the context does not need to.

Invocation: model+user

When to use

  • The user says "handoff", "hand off", "pass the baton", "takeover prompt", "write me a handoff", or the session is about to end / compact.
  • A long operation (multi-turn, multi-workstream) has state that must survive context loss: commits, branches, PRs, CI, blockers, decisions.
  • You are switching to a fresh session and want the new session to start from evidence instead of reconstructing the old one.

What to do

  1. Gather the truth from tools, not memory. Run/collect:

    • git branch --show-current, git status --short, git log --oneline origin/<default>..HEAD (what is local-only), git log --oneline -5 (recent context).
    • Live remote state where relevant (gh pr list --state open, gh pr checks <n>, gh run list) — only what the user's operation actually depends on; do not pad the handoff with a full GitHub dump.
    • Any in-flight work: dirty files, uncommitted slices, partial worktrees, running background jobs/workers, queued CI.
  2. Write a compact markdown handoff (aim under ~60 lines; the user may also ask for a "short text-only" variant — then aim under ~15 lines):

    # Handoff — <operation/session name> — <date>
    - **State:** <one-line: what is done vs in-flight vs blocked>
    - **Landed/committed:** <exact SHAs + one-line what>
    - **Branches/PRs:** <names + states; which are ours vs community>
    - **CI:** <what is green, what is waiting, what is broken>
    - **Blockers:** <exact blocker + what would unblock>
    - **Decisions made:** <the WHY that a fresh session must not re-litigate>
    - **Next step:** <the single next action, one line>
    - **Continuation records:** <pointers to partial work that must be
      preserved (worktrees, uncommitted files, receipts)>
    
  3. Persist it. Always write .codewhale/handoff.md in the workspace — that is the only path the runtime reads back. On the next session's first turn it is injected as the "## Previous Session Relay" block (HANDOFF_RELATIVE_PATH, crates/tui/src/prompts.rs:85; loader at prompts.rs:301-315). A handoff written anywhere else is never picked up, so the next session starts cold no matter how good the note is.

    Optionally also write a human-discoverable copy:

    • If the workspace has an ops/notes convention (e.g. codewhale-ops/notes/ with a living handoff file), update the living handoff's dated facts and snapshot, or create <topic>-handoff-<date>.md next to it.
    • Otherwise the repo root as HANDOFF.md or docs/handoff/<topic>-<date>.md. These are for people; nothing in the runtime reads them. Never overwrite someone else's uncommitted handoff without reading it first.
  4. Clear the way for the new session ("clears context"). A skill cannot delete the current context, but it can make the context disposable:

    • Ensure nothing is left only in memory: dirty work is either committed (WIP is fine with a real body), stashed with a note, or recorded in the handoff with its exact location.
    • Kill or record background work that would outlive the session (background jobs, sub-agents) — record what is still running and its task id.
    • Close with the one-line "next step" so the fresh session has an unambiguous first action.
  5. Deliver. Give the user the compact handoff text in your reply (the persisted file is the durable copy; the reply is the readable one).

Constraints

  • Facts only from tool output; never invent SHAs, check states, or blockers.
  • Keep claims narrower than evidence: distinguish landed/committed, verified locally, CI-verified, and pending.
  • Preserve other people's uncommitted work: read before touching, archive before overwriting.
  • The handoff is orientation, not law: tell the next session to refresh live state before acting on it.
  • If the user asks for a "short text-only" handoff, give exactly that in the reply and skip the full markdown file unless asked.

Reviews

No reviews yet. Tell others what you thought.

Comments

No login needed. Share how it worked for you, ask a question, or note where it did not run.

No comments yet. Be the first to write one.

Comments are published right away. Do not include personal information such as email addresses or phone numbers. Up to 2 URLs.

0 / 1,000 characters

This form is protected by reCAPTCHA, and the Google Privacy Policy and Terms of Service apply.

More skills from this repository

batch

FreeSummary

Split a large goal into clearly bounded tasks that can run in parallel. Coordinate existing agent and worktree tools, then combine and verify the results. The skill starts only when explicitly requested.

  • Splitting a large goal into parallel tasks
  • Coordinating work across multiple agents
  • Running tasks in separate worktrees
codewhale-hq/Codewhale41.1KUpdated Oct 19, 2026

best-of-n

FreeSummary

Generate independent options for design, implementation, explanations, or debugging, then compare them using one shared rubric. Code candidates use separate working copies and undergo independent verification before a winner is presented for review.

  • Comparing several plausible design approaches
  • Evaluating independent implementations of the same task
  • Comparing explanations or debugging approaches
codewhale-hq/Codewhale41.1KUpdated Oct 19, 2026

Check Codewhale release readiness through ordered tests, builds, version checks, and manual terminal checks. Record command results and observed behavior, including responsiveness, route isolation, and follow-up input handling, while explicitly identifying any skipped checks.

  • Run automated checks on the actual release branch
  • Check whether a PR merges into the release branch
  • Manually test terminal responsiveness and input behavior
codewhale-hq/Codewhale41.1KUpdated Oct 19, 2026

computer-use

FreeSummary

Operate desktop apps and isolated browsers on registered computers by inspecting interface controls, entering information, and checking results. The skill also covers screenshots and recording, with separate routing for the user's signed-in Chrome through Chromewhale.

  • Entering information through a desktop app interface
  • Working in an isolated browser session
  • Capturing screenshots or recordings for a task
codewhale-hq/Codewhale41.1KUpdated Oct 19, 2026

Check a local Codewhale checkout before contributing: inspect branch and sync status, build the CLI, and run the repository’s CI checks. Present recent commits and changelog entries from local files, with clear status for each step.

  • Checking a checkout before contributing
  • Reviewing local changes and sync status
  • Running the build and CI verification commands
codewhale-hq/Codewhale41.1KUpdated Oct 19, 2026

cw-dogfood

FreeSummary

Builds and installs Codewhale with a source revision identifier, then verifies the installed version in a fresh shell. It guides hands-on runtime checks for interface behavior, routing, approvals, and other changes that automated tests may miss.

  • Verifying terminal interface changes in the actual product
  • Installing and checking a local release build
  • Checking model routing and approval behavior
codewhale-hq/Codewhale41.1KUpdated Oct 19, 2026

See all skills by codewhale-hq

Report a problem with this skill