Share Brand Guidelines Between Cursor and Claude Code

You're building a client website. Cursor handles the code. Claude Code drafts the content. Both need the same brand guidelines—tone, colours, typography, the specific way they capitalise headings.

Most teams paste the brand guide into Cursor. Then paste it into Claude Code. Then paste it again when the conversation gets too long. Then paste the updated version when the client changes their mind halfway through the project.

It works. Sort of. But it's not sustainable—and it's definitely not professional.

Here's why the paste-everywhere approach breaks down, and how to share brand guidelines across AI tools the right way.

The Hard Way: Paste Into Each Tool

This is what most teams do right now. It's familiar, it's immediate, and it feels like it works.

How it looks

You receive brand guidelines from the client (Google Doc, PDF, Notion page). You:

Open Cursor, paste the brand guide into chat
Open Claude Code, paste the same brand guide
Reference parts of it as you work: "Use the primary colour from the brand guide"
When the conversation gets long, paste it again
When the client updates it, paste the new version—everywhere you pasted the old one

Why it feels reasonable

Zero setup time
Works with any AI tool
You control what gets pasted

And for a solo project with one client and one brief, it genuinely works. The problems show up later.

Where Paste-Everywhere Breaks Down

The paste approach works until it doesn't. Here's where it collapses under real agency conditions.

Stale context everywhere

The client updates their brand guidelines on Tuesday. On Wednesday, someone's AI conversation still references Tuesday's paste. Maybe you pasted it into three places—you only remember to re-paste into two of them.

Version drift is invisible until it isn't. A proposal goes out with the old rate card. A component ships with last month's colour palette. The AI was working from what you pasted—which wasn't the current version.

Different teammates, different pastes

You paste the brand guide into your Cursor conversation. Your colleague pastes it into theirs. Neither paste is visible to the other person.

You're both working on the same client, referencing the same guidelines, with no shared context. When they change, who updates? Everyone? Anyone who remembers?

Agencies end up with twenty copies of the same document scattered across individual chat histories—and no single source of truth.

No boundaries between clients

You're working on Client A in one tab and Client B in another. Both brand guides exist in your clipboard history. Both have similar names: "Brand Guidelines v2.pdf".

Paste the wrong one, and the AI applies Client B's tone to Client A's proposal. It happens. And there's no structural guard against it.

Zero audit trail

Client asks: "Can you prove the AI used our latest brand guidelines?"

You can't. You pasted it somewhere, at some point. Maybe you pasted the updated one later, maybe not. There's no log, no history, no proof—just your word that you did it right.

Burned tokens on repeat

Every paste burns context window. A 20-page brand guide pasted into five conversations across two tools? That's five full reads of the same document.

For complex guidelines or multiple clients, the token cost adds up fast. And it's entirely overhead—the same content, repeatedly fed into different conversations.

The Easy Way: Shared Structured Context

The alternative isn't "don't paste"—it's "paste once, structure it properly, share it everywhere."

Instead of each AI tool receiving its own copy of brand guidelines, you store guidelines in one place and let every tool read from that source.

What this looks like

You take the brand guidelines and add them to a context platform (like Vythos). You organise them:

Rules: Standing instructions that always apply. "Never use exclamation marks in Northwind copy." "Primary colour is #2D5F8B."
Facts: Context the AI should know but not follow as commands. "Northwind's audience is enterprise IT directors." "Their competitor is AcmeCorp."
Documents: The full brand guide, searchable but not automatically applied.

Then you connect Cursor and Claude Code to that platform via MCP.

When you work, you say: "Use Northwind's brand guidelines." The AI reads the live context from the shared source. And when guidelines change, every tool sees the change immediately.

Why this works better

One source of truth. The brand guidelines exist in one place. Update them there, and every connected tool sees the update. No re-pasting, no version drift, no "which version did I paste last week?"

Client isolation built in. Each client has their own context workspace. Work on Northwind, and only Northwind's guidelines are available. Client B's brand guide is invisible—structurally impossible to reference accidentally.

Zero duplication. Cursor reads the guidelines when needed. Claude Code reads the same guidelines when needed. No repeated pastes, no burned tokens on overhead.

Audit every read. Platform logs show: Cursor read the Northwind guidelines at 2:15pm. Claude Code read them at 3:42pm. Both saw the version updated at 9am.

When the client asks for proof, you have it.

Setting Up Shared Context (The Practical Version)

Option A: Build it yourself with MCP

Both Cursor and Claude Code support MCP. You can:

Store brand guidelines in a shared location (Google Drive, Notion)
Configure each tool to read from that location via MCP
Reference guidelines by name in conversations

This works, with caveats: - Each person sets up their own MCP connections - No central audit log - Client isolation depends on folder permissions—fragile - Managing ten clients means configuring ten connections per tool

Option B: Use a context platform

Platforms like Vythos handle the hard parts:

Add each client's brand guidelines, rate cards, and briefs to Vythos
Organise into rules, facts, and documents
Connect Cursor and Claude Code to Vythos via MCP (one connection per tool)
Every teammate with Vythos access can work with the same shared context

The platform adds: - Access controls (who sees what) - Audit trails (what was read, when) - Client isolation (no cross-contamination) - Version history (what changed, when)

For agencies managing multiple clients across multiple teammates, this is where the paste approach becomes untenable and shared context becomes table stakes.

What Day-to-Day Looks Like

The hard way (current state)

Morning: Client emails updated brand guidelines.

Afternoon: - Paste into Cursor chat (forget to paste into the other Cursor conversation) - Paste into Claude Code (use the old version from yesterday) - Colleague pastes into their Claude Code (uses the version from last week) - Three different brand guidelines, three different AI conversations

Evening: Proposal ships with wrong tone. No one knows whose paste was current.

The easy way (with shared context)

Morning: Client emails updated brand guidelines. You approve the change in Vythos.

Afternoon: - Open Cursor: "Use Northwind's brand guidelines" — reads live, current version - Open Claude Code: "Use Northwind's brand guidelines" — reads same version - Colleague does the same — same source, same version

Evening: Vythos log shows every read. Proposal ships with correct context. Client gets proof if they ask.

When Paste is Fine vs. When It Isn't

Paste works for: - Solo work on one project - One-off questions where persistence doesn't matter - Quick prototypes where accuracy isn't critical

Paste fails for: - Multiple teammates working on the same client - Multiple clients (risk of cross-contamination) - Documents that change (version drift) - Work requiring audit trails or proof of provenance - Complex rules that need structure, not raw text

If any of these describe your work, you've already outgrown the paste-everywhere approach—even if you haven't felt the pain yet.

The Honest Trade-Off

Shared context requires setup. The paste approach doesn't.

But setup scales. Paste doesn't.

The first time you connect Cursor and Claude Code to a shared context platform, it takes 15–30 minutes. That investment pays back on the second project with the same client—and compounds every time a teammate joins, a client updates their guidelines, or someone asks "which version did we use?"

For agencies, the question isn't whether shared context is worth it. The question is how much re-pasting you're willing to do before you make the switch.

The one thing: Pasting brand guidelines into each AI tool separately works until you have teammates, multiple clients, or documents that change. Shared context via MCP doesn't just save pastes—it prevents version drift, client bleed, and untraceable AI work. For agency work, it's the difference between "hope it's right" and "know it's right."

Start free at vythos.tech.