Hey, Mark and Peggy here.
What caps your client load is the reload.
Every time you sit down for a client you haven't touched in two weeks, you spend the first half hour climbing back into their world. Rereading the brand guide. Scrolling old emails to remember what tone you landed on. Checking which campaign you were in the middle of and why you made the call you made.
That reload is the tax. Pay it across eight clients and you've burned most of a day before you've written a sentence anyone will read.
I built a system that pays it down to almost nothing. One Claude Project per client, set up so the model remembers the client between sessions the way a good account manager would. Peggy tracked what it actually saved me, and she's going to keep me honest about where it falls apart.
Here's the build.
The Retainer Multiplier: Run More Clients Without Losing the Thread
The Tax You Pay Every Time You Switch Clients
You can write fast. That was never the bottleneck.
The bottleneck is that every client lives in a different world, and your head can only hold one or two of those worlds at a time.
When you open a project you haven't touched in eleven days, the world is gone. You have to rebuild it before you can work.
So you reread the brand guide. You open the last three things you wrote for them to recover the voice. You dig through email to remember that the founder hates the word "solutions" and that the last campaign underperformed because the offer was buried.
Forty-five minutes later you're finally writing, and you're writing for a client you used to know cold.
I timed this across Mark's accounts for a month before we built anything, because "it feels slow" isn't data. The reload ran 18 to 50 minutes per client per session, depending on how long it had been since he last worked on them. The gap was the variable that mattered most. Under a week, the reload was cheap. Past two weeks, it was brutal, and that's exactly the range a retainer book lives in.
The reason this caps your income is simple. Every new retainer adds another world to reload. At some point the reload tax eats the margin, and taking on client nine means doing worse work for clients one through eight.
So you stop. You tell yourself you're "at capacity," when the ceiling you've actually hit is memory.
The system fixes the remembering. That's the whole game.
What the System Is: One Persistent Project per Client
The setup is one Claude Project per client. Each Project is a brain for that client that persists between sessions, so you walk into every session with the world already rebuilt.
Each client brain holds four things: who the client is and how they sound, what you've already made for them, what's happening right now, and a standing instruction set that tells Claude how to act as that client's copywriter.
You build the brain once when you onboard a client. After that you maintain it in thirty seconds at the end of each session. The maintenance is the part people skip, and it's the part that makes the whole thing work, so I'll be specific about it later.
The brain has four components.
Component one is the reference layer: the durable facts about the client, like brand voice, audience, product, and the rules and preferences that don't change week to week.
Component two is the work archive. The copy you've actually shipped for them, so Claude can match what's already out there instead of inventing a new voice every session.
Component three is the session log. A running record of what happened each time you worked, what you decided, and what's open. This is the continuity layer, and it's the one that doesn't exist in most people's setups.
Component four is the project instructions. The standing prompt that tells Claude it's working as this specific client's copywriter and how to use the other three layers.
Let me walk through building each one.
Step 1: Build the Client Brain Before You Need It
Go to claude.ai/projects and create a new Project. Name it for the client. If you run a lot of accounts, prefix it so they sort together: "CLIENT — Ridgeline Outdoors," "CLIENT —Bellweather SaaS." The naming is trivial but you'll thank yourself when you have fourteen of them.
Into the Project knowledge, you're going to load the reference layer and the work archive. Here's what actually earns its place.
For the reference layer:
A voice profile. Not the client's marketing-deck "brand voice" page. The real one: the words they use, the words they ban, sentence rhythm, how formal, how much humor, what they sound like when they're good.
Audience notes. Who's reading, what they already know, what they're skeptical of, the awareness stage most of the copy targets.
Product and offer facts. What's true, what's claimable, what's off-limits for legal or positioning reasons.
Constraints. The founder hates "solutions." Legal won't approve comparative claims. Subject lines have to stay under fifty characters. Every preference you've learned the hard way.
For the work archive:
The last several pieces you shipped that you'd be happy to be judged by. Emails, pages, ads. Label each with what it was and how it did if you know.
One or two pieces that flopped, labeled as flops with a note on why. The misses teach Claude the boundaries faster than the hits.
Mark wanted to dump thirty samples in per client. I pushed back. We tested retrieval quality at five samples versus twenty, and past roughly eight to ten well-labeled pieces the voice match stopped improving and started drifting toward whatever was most recent in the pile. Curate. Eight pieces that represent the range beat thirty that bury it. The labels matter more than the volume.
You don't need this to be perfect on day one. You need it to be real. A rough voice profile plus six labeled samples beats a polished brand deck plus nothing, because the deck describes how the client wants to sound and the samples show how they actually sound.
Step 2: Write Instructions That Make Claude Act Like It Knows the Client
The project instructions are where you turn a folder of files into something that behaves like it works here. Paste this as a starting point and adapt the bracketed parts:
You are the copywriter for [CLIENT NAME]. You know this client's voice, audience, and history because they're in your knowledge base. Act like someone who has worked this account for a year, not someone seeing it for the first time.
The knowledge base contains:
- A voice profile (how this client sounds, the words they use and ban)
- Audience notes (who reads this and what they know)
- Product and offer facts (what's true and claimable, what's off-limits)
- Constraints (hard rules, legal limits, format requirements)
- A work archive (copy already shipped, some labeled as wins or flops)
- A session log (a running record of past sessions and open threads)
Before you write anything, do two things:
1. Read the most recent session log entry so you know where we left off.
2. Match the voice profile and the work archive, not a generic "good copy" default.
When you draft, stay inside the constraints. If a request would break one (a banned word, an unapprovable claim, a format limit), flag it instead of quietly working around it.
If something I ask for isn't covered by the knowledge base, say so and ask rather than inventing a fact about the client. Made-up specifics about a real client are worse than a question.
Default to matching what's already shipped. When you want to depart from the established voice, tell me you're departing and why.The "act like someone who has worked this account for a year" line does real work. Without it, Claude writes competent generic copy and waits for you to correct it toward the client. With it, it starts from inside the account.
The "read the most recent session log entry first" instruction is what makes continuity automatic. You'll build that log in the next step. The instruction is what makes Claude actually use it instead of treating it as decoration.
The "flag it instead of quietly working around it" rule is the one I'd never remove. The mistakes that actually cost you on retainer work are the claim legal won't approve that you didn't catch, or the banned word that reached the founder's inbox. You want the model surfacing those, not papering over them.
One more thing to consider here. Put the single most important constraint at the top of the instructions, not buried in the knowledge base. If the founder will fire you for one specific thing, that line earns its place in the standing prompt. I learned that with a client whose entire brand was "never sound like a startup," and the first three drafts sounded like a startup.
Step 3: Keep Context Alive with a Session Log
This is the component that separates a client brain from a folder of files. It's also the one almost nobody does, because it feels like overhead until the first time it saves you.
The session log is a single document in the Project knowledge that you update at the end of every working session. You add one short entry each time. It records what you did, what you decided, and what's still open.
At the end of a session, run this:
Write a session log entry for today in this format:
DATE: [today]
WORKED ON: [what we drafted or revised this session]
DECISIONS: [any calls we made — angle chosen, offer framing, voice adjustments, things the client approved or killed]
OPEN THREADS: [what's unfinished, what's waiting on the client, what to pick up next session]
WATCH: [anything I should remember next time — a new preference that surfaced, a constraint we discovered, a thing that almost went wrong]
Keep it tight. This is a note to my future self, not a report.Take the output, paste it at the top of your session log document, and re-upload it to the Project. The whole thing takes thirty seconds.
The next time you open that client, the start-of-session prompt (Step 5) reads the top entry and you're back in the world instantly. You don't reread old emails. You don't scroll to remember what you approved. The log remembers so you don't have to.
This is the component I was skeptical of and the one the numbers vindicated hardest. The reload time I mentioned earlier — the 18-to-50-minute tax — collapsed to under five minutes on accounts where the log was current. On accounts where Mark skipped the log for a couple sessions, it climbed right back up. Here's the precise version: the session log is what saves you time. Everything else is setup that makes the log usable.
The discipline is real, and I won't pretend it isn't. You have to write the entry when you're tired and want to close the laptop. The trick that made it stick for me: the entry is the last thing I do before I stop, and I let Claude draft it. I just approve what it writes.
Step 4: Spin Up a New Client Brain in One Sitting
The system only multiplies your client load if standing up a new brain is fast. If onboarding a client takes a day, you won't do it. Here's how to get a usable brain in one sitting.
When you sign a client, you already gather materials: their existing copy, brand guidelines, whatever the discovery call surfaced. Dump all of it into a fresh Project, then run this to build the reference layer:
I just signed this client. Everything I have on them is in this Project's knowledge: existing copy, brand materials, and my notes from the discovery call.
Build me a first-draft client brain. Produce four things:
1. VOICE PROFILE — how this client actually sounds based on their existing copy. The words they use, sentence rhythm, formality, humor level. Note the gap between how they describe their voice and how their copy actually reads, if there is one.
2. AUDIENCE NOTES — who they're writing to, what that audience knows, what they're skeptical of, the awareness stage most copy targets.
3. CONSTRAINTS — every rule, preference, or limit you can infer. Mark anything that's a guess with [GUESS] so I can confirm it.
4. OPEN QUESTIONS — the things you'd need to ask me or the client to make this brain accurate. Be specific.
Don't flatter the existing copy. If it's inconsistent, tell me where.That gives you a real starting brain in twenty minutes instead of a day. You read it, fix the guesses, get answers to the open questions on your next client call, and you're running.
The OPEN QUESTIONS section is the part that earns its keep. It turns your next client conversation into a targeted intake instead of a vague "tell me about your brand" chat. You walk in knowing exactly what the brain is missing.
Step 5: Open Every Session with the Same Prompt
The daily habit that ties it together is one prompt you run when you open any client Project:
Catch me up before we start.
Read the most recent session log entry and tell me:
- Where we left off
- What's open or waiting
- Anything I flagged to watch for
Then tell me what you'd suggest we tackle first based on the open threads. Don't start writing yet — just get us both oriented.That's the reload, done by the machine in fifteen seconds instead of by you in forty-five minutes. You read the catch-up, confirm or redirect, and start working inside a world that's already rebuilt.
Run it every time. The consistency is the point. When every client opens the same way, switching between eight of them stops feeling like eight separate cold starts.
Where This Breaks, and What to Do About It
A few honest failure modes, because this isn't magic and pretending it is would cost you.
The log goes stale and the system quietly stops working. If you skip the end-of-session entry for a few sessions, the catch-up prompt reads old information and confidently briefs you on a state of the world that's two weeks out of date. Stale continuity is worse than none, because you trust it. If you've been away from an account longer than the log covers, reread before you rely on the catch-up.
Voice drifts toward the most recent samples. If your last three shipped pieces for a client were unusually formal, the brain starts treating formal as the baseline. Periodically check that the work archive still represents the full range, not just the last quarter. Retire samples that no longer reflect where the client is.
The model will still invent client facts under pressure. The instructions reduce it. They don't eliminate it. If you ask for a specific stat or a customer detail the brain doesn't have, it can fabricate something plausible. Treat any specific claim about the client that you didn't put in the brain as unverified until you check it.
It doesn't write the copy. The brain rebuilds the world and matches the voice. The judgment is still yours. What you get back is a strong first draft that's on-voice and inside the constraints most of the time, and a draft that needs real work the rest of the time. The win is that you're never starting cold.
Worth saying plainly: the system pays off above a threshold and not below it. We modeled it across Mark's book. At three or four clients you can hold the worlds in your head, and the setup overhead isn't worth it. The math turns positive around six clients and gets steeper from there. If you're running five-plus retainers, this buys back a meaningful slice of your week. If you're running two, build the habit, but don't expect it to change your life yet.
The Master’s Memo & Burnett Matrix
Offload the worlds to a brain per client and the cap moves. Build one this week for your most context-heavy account and run the session log religiously for a month.
Track your reload time before you start and again after, because the session log is the component that buys back the hours. If that gap isn't obvious when you measure, your log isn't current.
Fix the habit before you blame the system.
More clicks, cash, and clients,
Mark & Peggy
