Teaching Claude your business.

Here's the thing nobody tells you on day one. Every time you open a new session, Claude starts with a blank mind. It doesn't remember yesterday's client call, the rule you gave it last week, or the fact that you can't stand long emails. And out of the box it can't see your business either: it can write a perfect reply to a client, but not read the email you're replying to. Left alone, it's a very smart temp who shows up fresh every morning, needs the whole briefing again, and works with the blinds down.

This chapter fixes both problems. First you give Claude notes, so it remembers who you are and how you work. Then you connect your tools, so it can see what's actually going on. Last, you settle where the few secrets it needs will live, so that none of this ever puts your accounts at risk.

A handbook and a brain.#

The fix for the blank mind is simple and a little old fashioned: notes. A folder of small text files that Claude reads on the way in and writes on the way out. We call it the brain. After a few months of daily use it holds hundreds of notes, and you'll have written almost none of them. Claude writes each one, usually right after you correct it or it finishes a job.

There are two kinds of memory at work. The first is a single file called CLAUDE.md, kept at ~/.claude/CLAUDE.md (a hidden folder in your home directory), that loads in every session no matter which folder you open. Think of it as the employee handbook: short, stable, rarely changed. It says how you work ("I do everything through the desktop app, so never tell me to open Terminal"), what "done" means to you (proof, like a screenshot or a live link, not a promise), and the short list of things Claude never does without your yes in the chat: send an email or message, spend money, delete things, post in public, share access. Each project can have its own CLAUDE.md too, with the rules for just that job.

The second kind is the brain itself, which Claude Code calls auto memory. It lives in a memory folder under ~/.claude/projects, one folder per place you open sessions, and holds a pile of notes plus one index file, MEMORY.md, with a single short line pointing to each note. Some notes are about you and how you like to work. Some track each project: where it stands, what was decided, what's next. Some are about where things live, like the fact that invoices are in QuickBooks and contracts sit in each client's Drive folder. And the most valuable ones are rules. The stack below shows what Claude actually reads, and when.

Every correction becomes a rule.#

This is the single most useful habit in this guide. Every time Claude gets something wrong that you never want to see again, say so plainly and ask for a rule.

No. Client emails are always short: answer their question, ask for the one thing you need, done. Save that as a rule, with the reason, near the top of the memory index.

Claude writes what it calls a feedback note: a small Markdown file (plain text with a few symbols for headings and bold) holding the rule, a Why line, and how to apply it. Here's roughly what that one looks like on disk.

---
name: Client emails stay short
type: feedback
---
Client emails: answer the question, ask for the one
thing we need, stop. No strategy, no side topics.

Why: a draft ran four paragraphs of strategy the client
never asked for. The owner wants an answer, not an essay.

How to apply: every client email and reply draft.

With the reason written down, Claude can handle cases the rule never mentioned. Then Claude adds one line to MEMORY.md pointing at the note, and that small line is what makes the rule stick, as the flow below shows.

Correct it once, and it stays corrected.

Ask Claude to keep one more running note, a "where were we" file of what's in flight, newest at the top. At the end of any real piece of work it adds two or three lines: what shipped, what's waiting on whom, where the files are. Tomorrow, or on the other computer, Claude reads it and picks up without a briefing.

One brain, kept short.#

Here's how brains fail. The index loads every session, but only its first 200 lines or 25KB, whichever comes first. Let it grow past that and anything near the bottom quietly stops being read. A rule below the cutoff is a rule Claude never sees, and one day it gets broken in front of a client.

So keep each index line to one short sentence that points at the full note, and put a small "read first" section at the very top with the handful of rules that must never break. Once a month, ask Claude to tidy up: merge duplicates, delete what's outdated, and keep the index well under the limit.

One quirk decides whether you have one brain or a dozen. The memory folder is named after where you open a session: the project's git repo (its tracked, backed-up folder), or the folder itself when there's no repo. A session opened on ~/Code/website gets a different memory than one opened on ~/Code. So open your everyday sessions on Code, the folder that holds all your projects side by side, and one brain covers everything. The always-on setup shows how to keep that brain in sync between two machines.

A few things never belong in the brain. Passwords and keys, never, for reasons we'll get to at the end of this chapter. Not what the project files already say, because they're the record for that; the brain holds the why and the what's next. And not things that are only true today. If it won't matter next week, it doesn't need a note.

Let Claude see your business.#

Memory tells Claude who you are. It still can't see your calendar, your inbox, or last month's invoices, and everything you want it to know has to be copied and pasted in. That gets old by lunchtime.

A connector fixes that one app at a time. Flip it on, sign in once, and Claude can see and work inside that service in every session from then on. Under the hood each connector is an MCP server (MCP, the Model Context Protocol, is the common plug that lets Claude talk to other apps), but you never have to think about that. You'll find them in Settings under Connectors, or from the + menu inside a session. There are official ones for Gmail, Google Calendar and Drive, GitHub, Vercel, Stripe, QuickBooks, Notion, Canva, Zapier, and plenty more. They're fast and precise, and they don't break when a website moves its buttons around.

Start where your day actually happens. For most businesses that's email, calendar, and files, with Chrome covering whatever is left, as the diagram below shows. With Gmail on, Claude reads a thread, finds what the client said three weeks ago, and writes a reply in your voice, in the right thread. With your calendar on, it preps you for tomorrow's calls and finds open time. With Drive on, it reads call transcripts, updates trackers, and builds the monthly report from the real numbers. After that, connect the places your money and your work live. Stripe and QuickBooks let it answer "who owes us?" mostly by reading, since money only moves with you. GitHub and Vercel let it publish and fix your sites.

If you're not sure where to begin, let Claude look first.

List the connectors I have and which are switched on. Based on how my business runs, tell me the five I should connect first, one line each, and open the settings page for the first.

The sign-in itself is one of the few things only you can do. Click through, approve, come back, and Claude takes it from there. It's worth starting gently, too.

Chrome for everything else.#

Plenty of tools have no connector: ad platforms, domain registrars, supplier portals, your industry's clunky CRM. For those, Claude works in your own Chrome through the Claude in Chrome extension. It reads the page and clicks like a person would, already logged in as you, and it stops and hands the wheel back when it hits a login or one of those "prove you're human" puzzles. For the rare desktop app with no web version at all, Claude can even drive the Mac itself with screenshots, mouse, and keyboard, but that's slower and still a research preview on Pro and Max, so treat it as the last resort.

And when a service offers an API, a door built for programs to talk to it, Claude can write a small script that uses it directly. For jobs that repeat every week, that's often the most reliable path of all, and a good reason to pick tools with a decent API when you have the choice. Connect everything with the company account, never one person's private login.

Drafts, never sends.#

Once Claude can see your inbox, one rule deserves its own line in your handbook. The Gmail connector can send email, not just draft it. So write it down: Claude writes drafts in the correct thread, and you read them and press Send. The same goes for anything else that goes out under your name, like messages, posts, and agreements for signature.

Claude writes the draft. You press Send. Nobody has ever regretted this rule.

It costs you ten seconds per email and saves you from the one reply that went to the wrong person, in the wrong tone, on the wrong day.

Keys, and where they live.#

All that connecting raises a fair question: what about passwords and keys? Here's the good news first. Most people reading this will never need an API key. Your Claude plan covers the app and Claude Code. Connectors sign in through a normal login page. Claude in Chrome uses the browser you're already logged into. You can run a whole business this way and never see a key.

Keys show up later, when you start building things that run on their own: a script that checks Stripe every morning, a job that sorts a thousand product descriptions overnight. Those programs can't click a login page, so the service gives them a key instead. An API key is a password for a program, a long string that says "this script is allowed to act on this account." Anyone holding your Stripe key can do what your Stripe key can do, and nobody types in a second factor or gets an alert. So treat a key exactly like a credit card number, just one that never expires on its own. The stack below sorts every kind of secret into its one home.

Your own logins, like Google, GitHub, the bank, and your domain registrar, live in your password manager and only there. You type them yourself on login pages; Claude never sees them. While you're in there, turn on two-factor sign-in for Google, GitHub, your registrar, and your hosting. Those are the accounts that, if taken over, take everything else with them.

Machine keys live in a private folder on each Mac, outside every project, where only your scripts read them. To share them between two machines and survive a dead laptop, ask Claude to set up a vault: it scrambles those files with an encryption tool and pushes only the scrambled copy to a private GitHub repo. One master key unscrambles it, and that key lives on the laptop, on the second Mac if you have one, and in your password manager. Print it once, too, and put it with your passport.

Then there are the places a key must never go. Never in the chat, because chats get logged and summarized; when a key needs saving, ask Claude to open the secrets file in a text editor for you, and paste it there yourself. Never in the brain, because the brain is backed up online every minute. And never in a project folder, because every git commit keeps a permanent copy of what was in it. Every repo gets a .gitignore rule (a list of files git must never save) that keeps secret files out, and before anyone else is given access to a repo, Claude scans its entire history for anything that looks like a key.

When a key is needed, give it the smallest power that works: read-only where possible, limited to one project, easy to cancel.

A Claude key, a leak, and the fine print.#

Sooner or later a script may want to call Claude directly. That takes an API key from the Anthropic Console, billed separately, per token (a token is roughly a short word). Your Pro or Max plan doesn't include API credits. The key is shown once when you create it, so it goes straight into the secrets folder, and before the first script runs, set a monthly spend limit on the Console's billing page. Adding the key won't change how the desktop app bills you; the app ignores it and keeps using your plan.

If a key ever leaks, replace it first and investigate second. Tell Claude the key was exposed and have it cancel the key at the provider, issue a new one, update the vault and every place it's used, and only then figure out where it got out. The old key is dead the moment it's cancelled, and that's the part that matters.

One last piece of fine print. Pro and Max run under Anthropic's consumer terms, which include a setting for whether your chats can help train future models (Settings, then Privacy, then "Help improve our AI models"). If you handle client data, check that setting, and consider a Team or Enterprise plan, which run under commercial terms. With notes it keeps, tools it can see, and keys it never touches, Claude stops being a temp and starts being staff.