Skip to content
Skills Library
AI & agents · Planning

working-memory

/working-memory

Maintain a project's mid-term working memory — a WORKING.md file in the repo holding the current stage's state (decision log, what was tried and failed, what's next) so it survives context compaction and new sessions. Use to set up WORKING.md in a project, to read it at the start of a session, to checkpoint progress into it after a meaningful step or before /compact, and to consolidate settled conclusions into long-term assistant memory (then reset WORKING.md) when a stage completes. Triggers: "set up working memory", "checkpoint", "save state", "resume where we left off", "consolidate memory"

Licence
MIT
Last repository change
06.09.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
5
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 06.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Maintain a project's mid-term working memory — a WORKING.md file in the repo holding the current stage's state (decision log, what was tried and failed, what's next) so it survives context compaction and new sessions. Use to set up WORKING.md in a project, to read it at the start of a session, to checkpoint progress into it after a meaningful step or before /compact, and to consolidate settled conclusions into long-term assistant memory (then reset WORKING.md) when a stage completes. Triggers: "set up working memory", "checkpoint", "save state", "resume where we left off", "consolidate memory"

Triggers from the description

s state (decision log, what was tried and failed, whatset up working memorycheckpointsave stateresume where we left offconsolidate memory
Original author description

Maintain a project's mid-term working memory — a WORKING.md file in the repo holding the current stage's state (decision log, what was tried and failed, what's next) so it survives context compaction and new sessions. Use to set up WORKING.md in a project, to read it at the start of a session, to checkpoint progress into it after a meaningful step or before /compact, and to consolidate settled conclusions into long-term assistant memory (then reset WORKING.md) when a stage completes. Triggers: "set up working memory", "checkpoint", "save state", "resume where we left off", "consolidate memory"

How it works

  1. Why
  2. The three levels
  3. The file
  4. Operations
  5. The belonging test
  6. Rules
Original SKILL.md headings · 59 lines, 690 words
SKILL.md preview
---
name: working-memory
description: >-
  Maintain a project's mid-term working memory — a WORKING.md file in the repo holding the current stage's state (decision log, what was tried and failed, what's next) so it survives context compaction and new sessions. Use to set up WORKING.md in a project, to read it at the start of a session, to checkpoint progress into it after a meaningful step or before /compact, and to consolidate settled conclusions into long-term assistant memory (then reset WORKING.md) when a stage completes. Triggers: "set up working memory", "checkpoint", "save state", "resume where we left off", "consolidate memory", "end of stage", or a mention of WORKING.md.
---

# Working Memory

## Why

A long session runs out of context and gets **compacted** — the transcript is squeezed into a summary, and the details drop out: decisions, edge-cases, what was already tried and failed. Work quality falls, and the next session starts blind — the user feels "didn't we already do this?".

Root cause: the important state lived **only in the conversation** — volatile memory that dies on compaction and never crosses into a new session. The fix is to stage that state onto a medium that survives: a `WORKING.md` file in the repo.

## The three levels

| Level | Medium | Lifespan |
|---|---|---|
| **Short-term** | session context | hours — dies on compaction |
| **Mid-term** | `WORKING.md` in the repo | days–weeks — while a stage runs |
| **Long-term** | the assistant's memory (e.g. Claude Code memory files) | months — survives everything |

This skill owns the mid-term level and the bridge up to long-term. Flow: **context → WORKING.md → (distill at stage end) → long-term memory.** WORKING.md is a *staging area* for memory, not a parallel store.

## The file

`WORKING.md` lives at the repo root (a working thread in a subfolder may have its own, e.g. `docs/research/WORKING.md`). Four sections:

- **Current stage** — one or two lines: where we are right now.
- **Decision log** — datestamped entries (absolute dates), newest-relevant on top: what was decided/done and *why*.
- **Tried / didn't work** — dead ends, so they aren't re-attempted.
- **Next** — open tails, TODOs, the obvious next step.

Copy `assets/WORKING.template.md` as the starting point.

## Operations

### Setup (once per project)
When a project has no WORKING.md and the work is non-trivial: copy the template to the repo root, fill **Current stage** from what's known, and add a pointer to the project's `CLAUDE.md` so it's read on every future session (snippet in `assets/CLAUDE-snippet.md`). If there is no `CLAUDE.md`, create one with just that pointer.

### Start / resume (every session)
At the start of work on a project, **read WORKING.md before acting** — it restores the stage state that context loss erased. Check subfolders for thread-specific WORKING.md too. If asked to "resume", this is the anchor.

### Checkpoint (often — the core habit)
After any meaningful decision or step — and **before a planned `/compact`, and whenever the user says "checkpoint / save state"** — append to WORKING.md: update **Current stage**, add 1–3 lines to the **Decision log**, record any new dead end, refresh **Next**. Do it *during* the work, not at session end — compaction can strike first. Keep entries terse; the quality bar is that a fresh session could resume from them.

### Consolidate (at stage end)
When a stage closes: **distill** the settled conclusions from WORKING.md up into long-term assistant memory, then **reset** WORKING.md to a clean slate for the next stage. Decide what rises with the belonging test below. This is the "sleep" step — without it, WORKING.md grows into an unreadable log and nothing reaches durable memory.

## The belonging test

For any line, ask: **"When this stage ends and WORKING.md is reset — should this survive?"**
- **Yes** → it's a settled conclusion (architecture, an infra fact, a hard-won gotcha, who-knows-what). → long-term memory.
- **No** → it's operational state (progress, an open tail, a TODO). → stays in WORKING.md, dies with the stage.

One event splits across levels: the *investigation* stays as a decision-log entry; the *lesson* rises to memory. Example — log: "spent a day chasing 87% 5xx, turned out to be bots on missing paths"; memory: "the catch-all handler must return 404 for unknown routes, not 500".

## Rules

- **Don't duplicate what code or git already show.** WORKING.md holds decisions and reasons, not a changelog you could `git log`.
- **Procedural knowledge** (how to deploy, how to test) belongs in `CLAUDE.md` or `docs/`, not WORKING.md — it's not stage state.
- **Absolute dates.** Resolve "tomorrow / next week" to a real date, so the log stays readable later.
- **Don't wait for stage end to write.** Mid-term memory only helps if it's written before context is lost.
Files in this package (5)
  • README.md 3 KB
  • SKILL.md 5 KB
  • .claude-plugin/plugin.json 1 KB
  • assets/CLAUDE-snippet.md 1 KB
  • assets/WORKING.template.md 1 KB

Versions

RepositoryScoreLicence
This page · ikotelkin/claude-skills100MIT
andreibesleaga/gabbe90CC-BY-4.0

Database snapshot: 13.11.2026 · package version 90c6c1cce0a2 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100dump
    Consolidate the current session's progress into the project's auto-memory directory — the "log everything, update state, prepare for resumption" drill. Use when the user says "log everything", "checkpoint", "save progress", "update memory", "dump state", or autonomously when a…
  • 91consolidate-memory
    Consolidate this project's durable memory — the agent equivalent of sleep-time memory consolidation. Reads recent session work + git history, verifies every candidate fact against the LIVE codebase, and reconciles BOTH memory stores (the repo's MEMORY.md/AGENTS.md/CLAUDE.md and…
  • 100handoff
    Generate a HANDOFF.md that captures goal, current state, files touched, failed attempts, and next steps — so a fresh Claude session can continue exactly where this one left off. Use when sessions are getting long, Claude keeps retrying the same broken solution, or the user wants…
  • 100session-state
    Maintain SESSION-STATE.md, the durable within-session memory that survives context compaction. Use when a constraint, settled decision, existing-infrastructure (survey) finding, or open thread must persist across a long session so it is not re-derived or re-litigated. Triggers…
  • 90project-memory
    Use when working in a repository that keeps durable project context, cross-session memory, incident history, decisions, or agent state across Claude, Codex, and later sessions.
  • 95engramory
    Curated, file-based long-term memory for an AI agent. Use this skill (1) at the start of a task or when resuming unfinished work to recall via the memory index, (2) during a task to save durable user, feedback, project, or reference facts, (3) when a task finishes, to run the…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.