Why does Bolt.new forget my design decisions?

Bolt.new forgets your design decisions because constraints you set in chat are just message tokens inside the same 200K-token Claude window as your code, and they are the first thing evicted as the project grows. The fix is to keep design rules in a persistent memory layer that loads back into every Bolt session.

Design decisions in Bolt are not "rules" in any structured sense. They are sentences in your chat history. That sentence has to compete for space with three things at every turn:

1. Your codebase. Bolt reads every file in the project on each prompt unless excluded via .bolt/ignore. As components multiply, the share of the window left for chat history shrinks.

2. The system prompt. Bolt's own instructions to Claude (formatting rules, file-write protocols, framework defaults) take a fixed slice of every turn.

3. The conversation tail. Recent messages are kept verbatim. Older messages — including the one where you said "Tailwind only, no CSS-in-JS" — get truncated as soon as the running total approaches the model's 200K-token cap.

There is no separate "rules layer" in Bolt. There is just the message stream, and message streams forget by design.

When the constraint disappears, the consequence shows up as code:

• Stack drift. Bolt re-introduces a library you explicitly rejected (Material UI, styled-components, Zustand) and you spend an hour ripping it out.
• Inconsistent components. Half the buttons use your design tokens; the new ones use raw Tailwind classes because Bolt no longer sees the token file in context.
• Architecture regressions. "Server components only for this route" gets forgotten, and Bolt converts the page to a client component on its next pass.

The compounding cost is worse than the per-incident cost. Every reverted decision teaches Bolt a slightly different version of the project, and the codebase drifts further from the original brief with each prompt.

StackBlitz gives you a few ways to push back, but none of them keep design decisions safe.

Inline reminders. You can prefix every prompt with "remember: Tailwind only". It works for one turn. Then the prefix itself starts consuming context.

The system prompt slot. Bolt lets you pin a small set of instructions at the top of the chat. The slot is short, shared with formatting rules, and resets per chat — not per project.

`.bolt/ignore`. Excluding generated folders frees up room for chat history, which indirectly preserves older decisions a little longer. It is a buffer, not a fix.

The official guidance from StackBlitz on token efficiency is documented in the Bolt help center. The honest takeaway from those docs: keep prompts tight, prune files, and accept that long-running projects will lose state.

Design decisions are the kind of context that needs to outlive any single chat. They are the project's constitution. Keeping them inside a rolling conversation window is like writing house rules on a whiteboard and resetting the whiteboard every few hours.

The problem deepens when you bring other tools in. The Tailwind rule you set in Bolt does not travel to v0 when you fork a screen for polish, and it certainly does not reach Cursor when you switch to backend work. Each tool needs the rules pasted in fresh.

MemoryLake gives your project a real rules layer that lives outside any single chat.

• Decisions stored as structured memory. Each design rule lives as a named entry in the Memories tab — "Styling: Tailwind + shadcn/ui only", "State: TanStack Query, no Redux", "Auth: Supabase, never Firebase". They are not buried in a chat log; they are first-class memory objects.
• Loaded into every new Bolt session. When you open a new Bolt chat, you pull the current rules from MemoryLake via REST and paste them as the first message. The chat starts with the project's constitution already in front of Bolt.
• Same rules in every other tool. The same memory feeds v0, Lovable, Cursor, Claude, and any AI that speaks REST or MCP. Switch tools mid-project and the design system follows.

MemoryLake scored 94.03% on the LoCoMo long-context benchmark with millisecond retrieval and AES-256 end-to-end encryption.

1. Create a project and load your design rules. Sign in to MemoryLake, open Project Management, click Create Project, and name it "Bolt — project rules". Upload your design system docs, brand guidelines, and any architectural decision records through the Document Drive. Add each non-negotiable rule as its own entry in the Memories tab so they are easy to retrieve.
2. Generate an MCP Server endpoint. Open the MCP Servers tab, click Add MCP Server, name it "Bolt design rules", and click Generate. Copy the Bearer token — it is shown only once.
3. Connect Bolt.new. Bolt has no native MCP client yet, so use the REST API with the Bearer token to fetch your rules bundle, then paste it as the opening message of any new Bolt chat. Developers can script this into a project-start hook so the rules load automatically.