Three files and three habits that turn Claude into a relationship partner — not a stranger you re-brief every time you open it
You manage ten clients. You remember all of it in your head.
That is not a system. That is a liability.
Every freelancer carries a mental client model. What each client cares about, what you last discussed, what you promised, what they owe you. The texture of twenty relationships — who's difficult, who's generous, who's likely to expand, who's probably churning.
This model lives in your head. Not in any file. Not anywhere Claude can reach it.
So every time you ask Claude to help you write a follow-up, draft a proposal, or think through a client situation — you start from zero. You paste in the background. You explain the relationship. You re-brief the history. Then you get an answer that is calibrated to the briefing you just wrote, not to the actual relationship you've been managing for eight months.
This is the memory tax. You pay it every single time.
You explain the same context over and over. The client's industry, their personality, the project history, what you're trying to achieve. Every session. The model never accumulates what you already know.
You said you'd send something by Friday. It's in an email thread somewhere. It never made it into a system. Two weeks later, the client mentions it in a call and you feel the heat of having dropped it.
A client you haven't spoken to in 60 days emails out of nowhere. You have no idea where you left things, what the last conversation was about, or what the relationship temperature is. You re-read the thread looking for context you should already have.
"Draft a check-in email to Sarah" produces a generic check-in email to a generic Sarah. Not a message calibrated to your actual relationship, her actual priorities, or the actual last thing you discussed. Generic context produces generic output.
Three clients have gone quiet. You don't have a system that tells you this. You find out when the contract doesn't renew. The signal was there — response times slowing, engagement dropping — but it lived in email and memory, not in a model you could query.
The memory tax compounds in the other direction. Every relationship that doesn't get logged is a relationship that gets worse over time — not because you don't care, but because the context degrades. You remember less. Claude knows nothing. The gap widens.
The system is three files. Each one covers a different layer of client context. Together they give Claude everything it needs to think with you — not just answer you.
Store them in a directory Claude Code can reach. ~/.claude/clients/ works cleanly. One subdirectory per client. Three files in each.
The permanent record. Who this client is, what they care about, how the relationship sits right now. This file changes slowly — update it when the relationship shifts, not after every call.
# [Client Name] Company: [Company name and what they actually do — one sentence] Contact: [Primary contact name, title] Since: [When the engagement started] Status: [Active / Paused / Renewing / At risk] Contract value: [Monthly retainer or project fee — the actual number] Renewal: [When the contract is up for renewal] ## What They Care About [2–3 sentences on their actual priorities — not their brief, their priorities. What they talk about when they're frustrated. What they celebrate. What outcome they're actually managing toward.] ## How They Work [Communication preferences: async or sync? Fast or deliberate? Do they like options or recommendations? What does "good work" look like to them?] ## Relationship Notes [The texture of the relationship. Warm / formal / guarded / collaborative. Any sensitivities. What you've noticed about what lands well or poorly.] ## Current Scope - [What you're actively working on for this client right now] - [Any scope changes or expansions in discussion]
The running record. Every significant conversation, in reverse chronological order. This is the temporal layer — it tells Claude how the relationship has moved over time and what the current state actually is.
# Entries in reverse order — newest at top ## [Date] — [Type: call / email / meeting / async] Topic: [What this interaction was about in 5 words] Signal: [Relationship temperature — warm / neutral / tense / enthusiastic] [3–5 bullet points of substance. What was discussed, what was decided, what was raised as a concern, what pleased them.] Next: [The single most important follow-up from this interaction] --- ## [Date] — [Type] [previous entry...]
The one file that prevents the missed commitment tax. Every promise, in both directions, with a due date. This is the file you reference when you open a project and ask "what am I supposed to have done?"
## Open — You owe them - [ ] Send revised proposal — by [date] — from [call on date] - [ ] Review their draft copy — by [date] — from [email on date] - [ ] Schedule Q2 planning call — no hard deadline ## Open — They owe you - [ ] Approve phase 2 scope — requested [date] - [ ] Send brand guidelines — requested [date] ## Closed - [x] Delivered monthly report — [date completed] - [x] Received signed contract — [date received]
The files only work if Claude can see them. The pattern is straightforward: reference them explicitly at the start of any client-related task.
"Read ~/.claude/clients/acme/ and help me draft a check-in email. Focus on moving the Q2 planning call forward."
That single instruction gives Claude everything. The client card tells it who Acme is and what they care about. The engagement log tells it what was last discussed and what the relationship temperature is. The commitment tracker tells it what's outstanding on both sides.
The output is not a generic check-in email. It is a message that reflects the actual relationship — the specific history, the current state, the real next step.
Other prompts that work once the files exist:
"Read ~/.claude/clients/[name]/ and brief me on where things stand before my call in 20 minutes."
"Update log.md with [what was discussed]. Extract any commitments and add them to commitments.md."
"Read all client commitments.md files and give me a summary of what's overdue and what's due this week."
A client intelligence system is only as valuable as its most recent update. The files you built last month reflect a relationship that has moved since then. Stale context is worse than no context in some cases — it directs Claude's attention toward information that is no longer true.
Three habits maintain the system with minimum friction:
Add an entry to log.md. Takes 5 minutes. Do it before you open the next thing on your list. If a commitment was made — in either direction — add it to commitments.md immediately. The window where you remember the details accurately closes fast.
Ask Claude to read all commitments.md files and surface what's overdue and what's due this week. Mark completed items. This is your relationship audit. It replaces the 30-minute "what was I supposed to be doing?" scan through email threads.
Update client.md when the relationship shifts — status change, scope change, relationship temperature change, key personnel change. This file moves slowly. Update it when it actually changes, not on a schedule. The log.md handles the day-to-day; client.md holds the current truth.
This system works. If you implement all three files and run the three habits consistently, your client relationships will be materially better within a month. The quality of Claude's output when you ask it to help with a client will be unrecognisable compared to the blank-slate alternative.
But manual systems have ceilings. Here is what breaks first, and why:
Manual context engineering is only as good as your last update. The gap between event and capture is the gap between what the system knows and what is actually true.
The manual system has a ceiling. Here is what exists beyond it.
Your Gmail syncs automatically. Every email from every client lands in a structured model — not just an archive, but context cross-referenced to the client card, the engagement log, and your open commitments.
When a call ends, the transcript is analyzed automatically. Commitments extracted. Relationship signal logged. The engagement log updated without you touching a file.
On Monday morning, Claude surfaces the three clients who have gone quiet in the last 30 days — not because you asked, but because the system tracks interaction frequency and flags the drift.
You ask "what do I owe Acme this week?" and Claude answers from a live model — not from a commitments.md you last updated three weeks ago. The commitment was captured when it was made, in the email thread where it was made, without your intervention.
The files compound. Every interaction enriches the model. Every email adds to the relationship picture. Every commitment logged and closed builds a record of your reliability. Six months in, Claude knows your client relationships better than your own memory does — because it has been tracking everything your memory dropped.
That is what Software of You does.
| File | What it holds | Update when |
|---|---|---|
| client.md | Who the client is, what they care about, relationship status, current scope | Status changes, scope changes, relationship shifts |
| log.md | Every significant interaction, in reverse order, with relationship signal | Within 15 minutes of every meaningful interaction |
| commitments.md | Open commitments in both directions, with source and due date | Immediately when a commitment is made or closed |
Start with one client. The one relationship you most wish Claude understood. Build the three files this afternoon. Run the system for two weeks. The improvement in output quality will make the case for the rest.
Software of You is a Claude Code plugin that builds and maintains your client intelligence system automatically. Gmail sync keeps the engagement log current without manual entries. CRM tracks relationship health. Conversation intelligence extracts commitments from transcripts. Everything cross-referenced. Everything on your machine.