Notepads: Session-Specific Context

Cursor Rules are always-on. CLAUDE.md files are permanent project documentation. Notepads fill a different niche: context that matters right now, not always.

What Notepads Are

A Notepad is a scratch document you can create in Cursor and drag into any chat conversation. It doesn't get committed to git. It's not a rule file. It's a chunk of text you want the AI to have for this specific session or task.

How to create one:

Cursor sidebar → Notepads section → "+" to create
Give it a name, write or paste content

How to use one:

Drag it into a chat conversation
Or reference it with @NotepadName

The Mental Model

Plain text

Rules file    = things that are always true about this project
CLAUDE.md     = permanent documentation and constraints
Notepad       = "here's what I'm focusing on today"

A Notepad is ephemeral by design. When you're done with the task, you don't need to clean it up — it's not part of your codebase.

When to Use a Notepad

The task spec: you're implementing a feature from a Jira ticket or design doc. Copy the relevant spec into a Notepad. Drag it into the chat at the start of each session.

Plain text

[Notepad: Checkout Redesign Sprint 3]

Acceptance criteria:
- Cart summary updates without page reload
- Discount codes apply immediately on entry
- Mobile layout uses stacked cards (not table)
- Error states show inline next to the relevant field

API contract (from backend team):
POST /api/cart/apply-discount
  body: { code: string }
  returns: { success: boolean, discount: number, error?: string }

Now the AI has the full spec. You don't re-paste it every message.

The architecture note: you're doing a refactor and want to explain the before/after structure.

Plain text

[Notepad: Data Fetching Refactor]

Current (what exists now):
- Each component fetches its own data with useQuery
- ProductList, UserCard, CartSummary all have their own API calls

Target (where we're going):
- Pages own all data fetching
- Components receive data as props
- One useQuery at the page level, passed down

Do NOT change the actual API calls or add new ones.
Only change where the fetching happens.

The bug context: you're chasing a weird bug and have accumulated observations.

Plain text

[Notepad: Cart Total Bug]

Bug: cart total shows wrong value for users with discount codes

What I've confirmed:
- The discount is applied correctly in the API response
- The bug only appears after a page refresh (not in-session)
- It doesn't happen in Safari — Chrome and Firefox only
- Cart state is managed in Zustand with persist middleware

Likely area: Zustand's persist/rehydration logic in src/store/cart.ts

The Notepad holds your working notes. The chat holds the conversation. They're separate.

What Notepads Are NOT For

Don't use Notepads for:

Conventions and patterns that should always apply → use Rules instead
Documentation the whole team should have → commit it to the repo as markdown
Instructions that should persist across all future sessions → use CLAUDE.md

The test: if you'd want this context in three months on a different machine, it's not a Notepad. It's a file.

Notepads vs. Markdown Files in the Repo

You might wonder: why not just create a task-context.md in the project?

The difference is intention and scope:

A markdown file in the repo is visible to git, visible to teammates, permanent
A Notepad is personal, session-scoped, invisible to the repository

Neither is better. Use the right one:

Team should know → markdown file in the repo
This session only → Notepad

A design doc that drove a feature decision belongs in the repo (or linked from it). Your personal working notes for this afternoon's debugging session belong in a Notepad.

Example: Using a Notepad for a Feature Sprint

Start of the sprint:

Open the design doc / product requirements
Create a Notepad: "Auth Redesign — Sprint 4"
Paste the requirements and acceptance criteria
Add your notes from the planning meeting

Each chat session during the sprint:

Open a new chat
Drag in the "Auth Redesign — Sprint 4" Notepad
Add the relevant files: @src/auth/ @src/components/AuthForm.tsx
Give the specific task for this session

The AI has the full context: what the feature needs to do, the acceptance criteria, and exactly which files are relevant. No re-explaining. No "as I mentioned earlier."

At the end of the sprint:

Archive or delete the Notepad — it served its purpose
Any decisions that should persist go into CLAUDE.md or proper docs

That's the Notepad value: front-load context once per sprint, reuse it across many sessions. It makes every chat session faster without cluttering your repository.