Claude Custom Instructions: What Goes There, What Goes in Stash

Published June 2026 · 6 min read

Claude's custom instructions (the system prompt you set in Claude's settings) are one of the most useful things most users underuse. They load silently at the start of every conversation. Claude reads them before you write a single word. Used well, they cut minutes of scene-setting per session.

But they have two constraints that matter:

1. They're global, not per-project. The same instructions apply whether you're working on a client proposal or debugging your Python script. You can't swap them mid-session without going to Settings.
2. They're static. They describe who you are and how you like to work. They don't track what you're working on, what changed last week, or what you asked Claude to remember three sessions ago.

The right mental model: custom instructions tell Claude about you. Stash tells Claude about what you're doing right now. Used together, they make Claude feel like it actually knows you — not just as a persona, but as someone with live context.

What belongs in custom instructions

Custom instructions are for stable facts about you that are true across every conversation:

• Your role and professional background
• Output format preferences (bullet points vs. prose, code style, response length)
• Communication style preferences (direct and terse vs. explanatory)
• Topics Claude should handle carefully or flag
• Recurring requests you'd otherwise have to make every session

A good custom instruction example:

I'm a backend developer, primarily Python and Go. I prefer direct answers
without preamble. When you show code, include the minimal working example
— don't pad with error handling I didn't ask for. When you're uncertain,
say so clearly rather than hedging throughout. I work in UK English.

That's about 50 words. It's precise, it's always true, and it genuinely changes Claude's output in every conversation. That's the target.

A bad custom instruction example:

I'm working on a FastAPI project with a database. We're building a
multi-tenant SaaS for recruitment agencies. The main challenge right now
is performance — the search endpoint is slow. We use Alembic for migrations.
The staging environment is at staging.myapp.com. The team uses conventional
commits. We're mid-sprint until Friday.

This is project context masquerading as personal preferences. It's wrong in half of your conversations, it goes stale inside a week, and you'd have to edit custom instructions every time the project changes. This belongs in Stash, not custom instructions.

What belongs in Stash

Stash is where live context lives. The things that change per project, per week, per sprint:

• Active project details, current focus, open decisions
• Client and stakeholder notes
• Architecture decisions and why you made them
• Things you asked Claude to remember in previous sessions
• Reference material you query occasionally (glossary, conventions, checklists)

You pull Stash context into a conversation with a single call:

context("project-name")

Claude fetches the relevant records, returns a brief summary, and the conversation proceeds with full context. The custom instructions already told Claude how you like to communicate; Stash told it what you're working on.

The combined pattern in practice

Here's how a developer uses both in a morning session:

Developer: context("auth-refactor")

Claude: Found 3 records:

  project: Auth refactor — replacing JWT with session tokens.
  Currently mid-implementation on the middleware layer. Next
  step is updating the test suite.

  open-questions: Still undecided on refresh token storage
  (cookie vs. localStorage). Pending security review.

  env-notes: Dev environment requires SESSION_SECRET env var
  set manually — not in .env.example yet.

Developer: What's the tradeoff on cookie vs. localStorage for
refresh tokens?

Claude: [direct, terse answer matching custom instructions — no
preamble, minimal hedging, UK English]

Custom instructions shaped the response style. Stash shaped the context. The developer didn't explain either — they just started working.

A practical template for custom instructions

Here's a template to steal and adapt. Keep it under 300 words — leave room for Claude's own processing:

Role: [your job title and main specialisms in one sentence]

Preferences:
- Response length: [terse / detailed / match the question]
- Code examples: [always / only when asked / minimal working examples only]
- Uncertainty: [flag clearly / hedge inline]
- Language: [UK / US English]

Background: [2-3 sentences on your technical background, tools you use regularly]

Standing requests:
- [Anything you'd otherwise ask every session, e.g. "Always suggest the
  simpler approach first"]
- [Any topics where you want Claude to be especially careful]

Keep the Background section high-level. Domain knowledge, tool familiarity, experience level. Not project details — those go in Stash.

The limit worth knowing about

Claude's custom instructions have a character limit (around 1,500 characters in the web interface — the exact number has shifted over time). If you're hitting it, that's a sign you're trying to fit project context into a personal-preferences slot. Extract the project-specific content and put it in Stash instead. The custom instructions should never need to be long.

Getting started

Two steps:

1. Audit your current custom instructions. Anything that would be wrong in 20% of your conversations? Move it to Stash.
2. Add the Stash connector (URL below). Create one collection for your main active project. Add three records: what the project is, what you're working on this week, and one decision worth remembering.

The two tools are complementary. Custom instructions are set-and-forget. Stash is the live layer you build as you work.

Pricing

Free tier works for most individual users. Pro (£8/month) removes limits for heavier use. Pricing may change; cancel anytime.