Context and knowledge management

Skill 10: Memory, Context & Knowledge Management

Purpose: Manage your own working state so you don't lose track, forget decisions, or repeat work, especially across long or interrupted tasks. Use when: Any task with many steps, spanning more than one sitting, or where you're juggling more than you can reliably hold in your head. Don't use when: A short task you'll finish in one focused pass with everything in view. Don't build elaborate note systems for a five-minute job.

---

Why this matters

This skill is especially critical for weaker AI models and anyone working under a limited attention/context budget. A model with a small context window, or a person interrupted across days, will silently lose the plan, forget a decision they made an hour ago, re-solve a problem they already solved, or lose track of what's done. The output degrades not because the reasoning is bad but because the working state fell out of memory.

The fix is to stop relying on your head as the source of truth and instead externalize your working state into durable, re-readable artifacts. Your memory is a cache: fast but small and lossy. Write things down so you can reload them.

The core principle

Treat your own memory as unreliable and offload the truth to the page. Anything you must not forget (the goal, the plan, decisions, open questions, findings) lives in a written artifact you re-read, not only in your head. When context is lost, you recover it by reading, not by guessing.

---

What to externalize (and where)

Keep a small set of living artifacts. For a simple task this is one scratch file; for a big one it's a few.

Artifact	Holds	Why
The goal / brief	One-sentence goal, success criteria	So you never drift from what "done" means
The plan / task list	Ordered tasks, what's done, what's next	So you always know where you are
Decision log	Choices + one-line reasons ("chose X because Y")	So you don't re-litigate or forget why
Findings / working notes	What you've learned, what you tried, dead ends	So you don't repeat research or failed attempts
Open questions / blockers	Unknowns, things to confirm	So they're not forgotten until they bite

Keep them short and current. A stale note is worse than none because it misleads.

---

Working habits for context discipline

Re-ground before you act

At the start of a work session, or when returning to a task, re-read your goal and plan before doing anything. Thirty seconds of re-reading prevents an hour of confidently building the wrong next thing. Never resume a task from your assumption of where you were: read where you actually were.

Write the decision when you make it, not later

The moment you choose something ("I'll use approach A"), write the one-liner. Reconstructed reasons are unreliable and often wrong. This is cheap insurance (first-principles-reasoning covers the format).

Record dead ends

"Tried X, didn't work because Y" is as valuable as what worked: it stops you (or a successor) from wasting time re-trying X. A list of what doesn't work is real knowledge.

Keep one source of truth

Don't scatter the same information across five places that drift apart. One plan file, one decision log. When something changes, update the one place. Duplicated state is state that will disagree.

Checkpoint before risky or context-heavy moves

Before a large change, a risky operation, or anything that might blow up: save a known-good state (commit, snapshot, copy) and jot where you are. This gives you a return point, the safety net from implementation-strategy.

Summarize before you lose context

If you're approaching a limit, a long session, an interruption, a context window filling up, write a handoff summary while you still remember: goal, what's done, what's next, key decisions, open questions. Then you (or the next worker) resume from the summary instead of from nothing. This is the single most important habit for long-horizon work under limited memory.

---

Handoff / checkpoint template

Write this whenever you stop mid-task or hand off. It's what "future you" reads to resume instantly.

STATUS SNAPSHOT: <task name>, <date/time>
Goal: <one sentence>
Done: 
  - <completed items>
Next up: 
  - <the very next action, concretely>
Key decisions: 
  - <choice> because <reason>
Open questions / blockers: 
  - <unknowns to resolve>
Known-good state: <where it is, commit id, file, snapshot>
Gotchas / dead ends: 
  - <what not to retry, and why>

If you write nothing else, write "Next up." A concrete next action is what turns a cold restart into a warm one.

---

Worked example

Situation: A multi-day data-cleaning project. Day 1 you figure out the tricky date-parsing logic and decide to drop rows before 2019. Day 3 you come back.

Without context management: Day 3, you've forgotten the 2019 cutoff decision and why, re-investigate the date parsing you already solved, and accidentally re-introduce a bug you'd fixed. Hours lost to re-learning your own work.

With context management: Day 1 you wrote:

STATUS SNAPSHOT: data cleaning, day 1
Done: date parser handles the 3 formats (see notes: the ISO-with-timezone case was the tricky one).
Next up: apply the parser to the full dataset and write out cleaned file.
Key decisions: drop rows before 2019-01-01 because the source system's data is unreliable before then (confirmed with data owner).
Dead ends: tried pandas auto-parse, fails silently on the mixed formats, do NOT use it.
Known-good state: cleaned_v1.csv + parser.py committed.

Day 3 you read this in thirty seconds and resume exactly where you were, with every decision and trap intact.

---

Common failure modes

Failure	Fix
Relying on memory across sessions	Externalize goal, plan, decisions to files.
Losing the plan mid-task	Re-read it before each work session.
Forgetting why a choice was made	Log the decision when you make it.
Re-trying known dead ends	Record what didn't work and why.
State scattered and contradictory	One source of truth per kind of info.
Cold restart after interruption	Leave a handoff snapshot before stopping.
Note files rot and mislead	Keep them short and update the one place.

Red flags: stop and externalize

• You're unsure whether you already did something.
• You can't remember why you made an earlier decision.
• You're re-researching something that feels familiar.
• You're about to stop mid-task with nothing written down.
• The plan exists only in your head and the task is large.
• Your context/attention is filling up and you haven't summarized.

Definition of done for this skill

• Goal, plan, and decisions live in re-readable artifacts, not only memory.
• You re-ground (re-read) when resuming.
• Decisions and dead ends are logged as they happen.
• There's one source of truth per kind of information.
• A handoff snapshot exists before any stop/interruption on a long task.

See also

• planning-and-decomposition, the plan is a primary externalized artifact.
• documentation-and-knowledge-capture, turning working notes into durable docs.
• long-horizon-project-management, context management scaled to whole projects.
• first-principles-reasoning, the decision-record format.