Napkin

You maintain a per-repo markdown file that tracks mistakes, corrections, and patterns that work or don't. You read it before doing anything and update it continuously as you work — whenever you learn something worth recording.

This skill is always active. Every session. No trigger required.

Session Start: Read Your Notes

First thing, every session — read .scratch/napkin.md before doing anything else. Internalize what's there and apply it silently. Don't announce that you read it. Just apply what you know.

If no napkin exists yet, create one at .scratch/napkin.md

# Napkin

## Corrections
| Date | Source | What Went Wrong | What To Do Instead |
|------|--------|----------------|-------------------|

## User Preferences
- (accumulate here as you learn them)

## Patterns That Work
- (approaches that succeeded)

## Patterns That Don't Work
- (approaches that failed and why)

## Domain Notes
- (project/domain context that matters)

Adapt the sections to fit the repo's domain. Design something you can usefully consume.

Continuous Updates

Update the napkin as you work, not just at session start and end. Write to it whenever you learn something worth recording:

• You hit an error and figure out why. Log it immediately. Don't wait.
• The user corrects you. Log what you did and what they wanted instead.
• You catch your own mistake. Log it. Your mistakes count the same as

user corrections — maybe more, because you're the one who knows what went wrong internally.

• You try something and it fails. Log the approach and why it didn't work

so you don't repeat it.

• You try something and it works well. Log the pattern.
• You re-read the napkin mid-task because you're about to do something

you've gotten wrong before. Good. Do this.

The napkin is a living document. Treat it like working memory that persists across sessions, not a journal you write in once.

What to Log

Log anything that would change your behavior if you read it next session:

• Your own mistakes: wrong assumptions, bad approaches, misread code,

failed commands, incorrect fixes you had to redo.

• User corrections: anything the user told you to do differently.
• Tool/environment surprises: things about this repo, its tooling, or its

patterns that you didn't expect.

• Preferences: how the user likes things done — style, structure, process.
• What worked: approaches that succeeded, especially non-obvious ones.

Be specific. "Made an error" is useless. "Assumed the API returns a list but it returns a paginated object with .items" is actionable.

What Not to Log

Keep the napkin safe to store in the repo:

• Don’t record secrets (API keys, tokens, passwords), private URLs, or internal

credentials.

• Don’t paste large stack traces or logs; summarize the failure and the fix in

one line, and point to a command/file instead.

Napkin Maintenance

Every 5-10 sessions, or when the file exceeds ~150 lines, consolidate:

• Merge redundant entries into a single rule.
• Promote repeated corrections to User Preferences.
• Remove entries that are now captured as top-level rules.
• Archive resolved or outdated notes.
• Keep total length under 200 lines of high-signal content.

A 50-line napkin of hard-won rules beats a 500-line log of raw entries.

Example

Early in a session — you misread a function signature and pass args in the wrong order. You catch it yourself. Log it:

| 2026-02-06 | self | Passed (name, id) to createUser but signature is (id, name) | Check function signatures before calling, this codebase doesn't follow conventional arg ordering |

Mid-session — user corrects your import style. Log it:

| 2026-02-06 | user | Used relative imports | This repo uses absolute imports from `src/` — always |

Later — you re-read the napkin before editing another file and use absolute imports without being told. That's the loop working.