write-continue-here
Write a CONTINUE_HERE.md file capturing current session state so a fresh Claude Code session can pick up where this one left off. Covers assessing recent work, structuring the continuation file with objective, completed, in-progress, next-steps, and context sections, and verifying the file is actionable. Use when ending a session with unfinished work, handing off context between sessions, or preserving task state that git alone cannot capture.
Best use case
write-continue-here is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Write a CONTINUE_HERE.md file capturing current session state so a fresh Claude Code session can pick up where this one left off. Covers assessing recent work, structuring the continuation file with objective, completed, in-progress, next-steps, and context sections, and verifying the file is actionable. Use when ending a session with unfinished work, handing off context between sessions, or preserving task state that git alone cannot capture.
Teams using write-continue-here should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/write-continue-here/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How write-continue-here Compares
| Feature / Agent | write-continue-here | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Write a CONTINUE_HERE.md file capturing current session state so a fresh Claude Code session can pick up where this one left off. Covers assessing recent work, structuring the continuation file with objective, completed, in-progress, next-steps, and context sections, and verifying the file is actionable. Use when ending a session with unfinished work, handing off context between sessions, or preserving task state that git alone cannot capture.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Write Continue Here Write a structured continuation file so the next session starts with full context. ## When to Use - Ending a session with work still in progress - Handing off a complex task between sessions - Preserving intent, failed approaches, and next steps that git cannot capture - Before closing Claude Code when mid-task ## Inputs - **Required**: An active session with recent work to summarize - **Optional**: Specific instructions about what to emphasize in the handoff ## Procedure ### Step 1: Assess Session State Gather facts about recent work: ```bash git log --oneline -5 git status git diff --stat ``` Review the conversation context: what was the objective, what was completed, what is partially done, what was tried and failed, what decisions were made. **Got:** Clear understanding of current task state — completed items, in-progress items, and planned next steps. **If fail:** If not in a git repository, skip git commands. The continuation file can still capture conversational context and task state. ### Step 2: Write CONTINUE_HERE.md Write the file to the project root using the structure below. Every section must contain actionable content, not placeholders. ```markdown # Continue Here > Last updated: YYYY-MM-DDTHH:MM:SSZ | Branch: current-branch-name ## Objective One-paragraph description of what we are trying to accomplish and why. ## Completed - [x] Finished item with key file paths (e.g., `src/feature.R`) - [x] Decisions made and their rationale ## In Progress - [ ] Partially complete work — describe current state (branch, file:line) - [ ] Known issues with partial work ## Next Steps 1. Immediate next action (most important) 2. Subsequent actions in priority order 3. **[USER]** Items needing user input or decision ## Context - Failed approaches and why they did not work - Key constraints or trade-offs discovered - Relevant issue/PR links ``` Guidelines: - **Objective**: Capture the WHY — git log shows what changed, not why - **Completed**: Mark items clearly done to prevent re-work - **In Progress**: This is the highest-value section — partial state is hardest to reconstruct - **Next Steps**: Number by priority. Prefix user-dependent items with `**[USER]**` - **Context**: Record negative space — what was tried and rejected, and why **Got:** A CONTINUE_HERE.md file at the project root with all 5 sections populated with real content from the current session. The timestamp and branch are accurate. **If fail:** If Write fails, check file permissions. The file should be created in the project root (same directory as `.git/`). Verify `.gitignore` contains `CONTINUE_HERE.md` — if not, add it. ### Step 3: Verify the File Read back CONTINUE_HERE.md and confirm: - Timestamp is current (within the last few minutes) - Branch name matches `git branch --show-current` - All 5 sections contain real content (no template placeholders) - Next Steps are numbered and actionable - In Progress items describe current state specifically enough to resume **Got:** The file reads as a clear, actionable handoff that a fresh session could use to immediately resume work. **If fail:** Edit sections that contain placeholder text or are too vague. Each section should pass the test: "Could a fresh session act on this without asking clarifying questions?" ## Validation - [ ] CONTINUE_HERE.md exists at the project root - [ ] File contains all 5 sections with real content (not placeholders) - [ ] Timestamp and branch are accurate - [ ] `.gitignore` includes `CONTINUE_HERE.md` - [ ] Next Steps are numbered and actionable - [ ] In Progress items specify enough detail to resume without questions ## Pitfalls - **Writing placeholders instead of content**: "TODO: fill in later" defeats the purpose. Every section must contain real information from the current session. - **Duplicating git state**: Do not list every file changed — git already tracks that. Focus on intent, partial state, and next steps. - **Forgetting the Context section**: Failed approaches are the most valuable thing to record. Without them, the next session will retry the same dead ends. - **Overwriting without reading**: If CONTINUE_HERE.md already exists from a prior session, read it first — it may contain unfinished work from an earlier handoff. - **Leaving stale files**: CONTINUE_HERE.md is ephemeral. After the next session consumes it, delete it. Stale files cause confusion. ## Related Skills - `read-continue-here` — the complement: reading and acting on the continuation file at session start - `bootstrap-agent-identity` — cold-start identity reconstruction that consumes the continuation file this skill produces - `manage-memory` — durable cross-session knowledge (complements this ephemeral handoff) - `commit-changes` — save work to git before writing the continuation file - `write-claude-md` — project instructions where optional continuity guidance lives
Related Skills
skill-name-here
One to three sentences describing what this skill accomplishes, followed by key activation triggers. This field is the primary mechanism agents use to decide whether to activate the skill — it is read during discovery before the full body is loaded. Start with a verb. Include the most important "when to use" conditions inline. Max 1024 characters.
write-vignette
Create R package vignettes using R Markdown or Quarto. Covers vignette setup, YAML configuration, code chunk options, building and testing, and CRAN requirements for vignettes. Use when adding a Getting Started tutorial, documenting complex workflows spanning multiple functions, creating domain-specific guides, or when CRAN submission requires user-facing documentation beyond function help pages.
write-validation-documentation
Write IQ/OQ/PQ validation documentation for computerized systems in regulated environments. Covers protocols, reports, test scripts, deviation handling, and approval workflows. Use when validating R or other software for regulated use, preparing for a regulatory audit, documenting qualification of computing environments, or creating and updating validation protocols and reports for new or re-qualified systems.
write-testthat-tests
Write comprehensive testthat (edition 3) tests for R package functions. Covers test organization, expectations, fixtures, mocking, snapshot tests, parameterized tests, and achieving high coverage. Use when adding tests for new package functions, increasing test coverage for existing code, writing regression tests for bug fixes, or setting up test infrastructure for a package that lacks it.
write-standard-operating-procedure
Write a GxP-compliant Standard Operating Procedure (SOP). Covers regulatory SOP template structure (purpose, scope, definitions, responsibilities, procedure, references, revision history), approval workflow design, periodic review scheduling, and operational procedures for system use. Use when a new validated system requires operational procedures, when existing informal procedures need formalisation, when an audit finding cites missing procedures, when a change control triggers SOP updates, or when periodic review identifies outdated procedural content.
write-roxygen-docs
Write roxygen2 documentation for R package functions, datasets, and classes. Covers all standard tags, cross-references, examples, and generating NAMESPACE entries. Follows tidyverse documentation style. Use when adding documentation to new exported functions, documenting internal helpers or datasets, documenting S3/S4/R6 classes and methods, or fixing documentation-related R CMD check notes.
write-incident-runbook
Create structured incident runbooks with diagnostic steps, resolution procedures, escalation paths, and communication templates for effective incident response. Use when documenting response procedures for recurring alerts, standardizing incident response across an on-call rotation, reducing MTTR with clear diagnostic steps, creating training materials for new team members, or linking alert annotations directly to resolution procedures.
write-helm-chart
Create production-ready Helm charts for Kubernetes application deployment with templating, values management, chart dependencies, hooks, and testing. Covers chart structure, Go template syntax, values.yaml design, chart repositories, versioning, and best practices for maintainable and reusable charts. Use when packaging a Kubernetes application for repeatable deployments, parameterizing manifests for multiple environments, managing complex multi-component applications with dependencies, or standardizing deployment practices with versioned rollback capability across teams.
write-claude-md
Create an effective CLAUDE.md file that provides project-specific instructions to AI coding assistants. Covers structure, common sections, do/don't patterns, and integration with MCP servers and agent definitions. Use when starting a new project where AI assistants will be used, improving AI behavior on an existing project, documenting project conventions and constraints, or integrating MCP servers or agent definitions into a project workflow.
read-continue-here
Read a CONTINUE_HERE.md continuation file at session start and resume from where the prior session left off. Covers detecting the file, assessing freshness, parsing the structured handoff, confirming the resumption plan with the user, and cleaning up after consumption. Optionally configures a SessionStart hook and CLAUDE.md instruction for automatic pickup. Use at the start of a session when a continuation file exists, when bootstrapping after an interrupted session, or when setting up automatic continuation detection.
build-coherence
AI multi-path reasoning coherence using bee democracy — independent evaluation of competing approaches, waggle dance as reasoning-out-loud, quorum sensing for confidence thresholds, and deadlock resolution. Use when forage-solutions has identified multiple valid approaches and a selection must be made, when oscillating between options without committing, when justifying an architecture or tool choice with structured reasoning, or before an irreversible action where the cost of the wrong choice is high.
vishnu-bhaga
Preservation and sustenance — maintaining working state under perturbation, memory anchoring, consistency enforcement, and protective stabilization. Maps Vishnu's sustaining presence to AI reasoning: holding what works steady, anchoring verified knowledge against drift, and ensuring continuity through change. Use when a working approach is at risk from scope creep, when context drift threatens verified knowledge, after shiva-bhaga dissolution to protect what survived, when a long session risks losing earlier decisions through context compression, or before making changes to a currently functioning system.