# Teach it how you work. Two things go in this chapter. A file that tells the agent who you are, and a rule that tells it which commands it may run without stopping to ask. Together they're worth more than any technical skill in this guide. ## The file that changed everything for me Claude Code reads a file called `CLAUDE.md` in whatever folder you're working in, every single session, automatically. Whatever you put in it becomes standing instructions. Most people leave it empty or fill it with technical notes. That's a waste. The most useful thing I ever put in mine had nothing to do with code: ``` I have ADHD and I am not a developer. Adjust how you talk to me: - Lead with the answer. First sentence is what happened or what you recommend. Detail after. - Plain English. If a technical term is unavoidable, define it in the same sentence. - No walls of text. No arrow-chains. No jargon I'd have to look up. - Be the organized one. I context-switch constantly. Track the loose ends and surface them to me. - Give me a recommendation, not a menu of five options. - One thing at a time. If a task grows tentacles, name the tentacles and propose an order. ``` The difference was immediate and it was not subtle. The agent stopped handing me dense technical dumps I'd skim and misunderstand, and started handing me answers I could act on. If you have ADHD, or you're dyslexic, or English is your second language, or you just hate being talked down to — **say so, in the file.** It will listen. Every session. Forever. > **This is the actual unlock** > > Everyone spends their energy trying to write better prompts. Almost nobody spends an hour telling the model who they are and how they need to be spoken to. The second one compounds across every conversation you will ever have. Do that one first. ## A starter file you can steal Create `CLAUDE.md` in your project folder and adapt this. Everything in it is something I use. ``` # Working with me — read this first ## Who I am I run a business. I am not an engineer and I do not write the code. Explain what a thing *does* and *why it matters* before you name the tool or the file. ## How to talk to me - Lead with the answer, detail after. - Plain English. Define any term you have to use. - Short paragraphs, not walls. - Recommend, don't present a menu. Note the real trade-off. - Ask a sharp question if the request is ambiguous — but don't ask me things you could just go check yourself. - Track my loose ends and surface them. I forget. ## How I want you to work - Commit to git before you start anything nontrivial. - Never delete or overwrite something you didn't create without showing me first. - After you change something, actually run it and confirm it works. Don't tell me it's done because it should be. - If tests fail, say so and show me the output. Don't hedge. - Prefer boring, proven tools over clever new ones. ## What this project is [One paragraph. What it does, who uses it, what would be a disaster if it broke. Update this as it grows.] ## Money - No paid APIs or paid SaaS without asking me first. - Default to the cheapest model that can do the job. - If a free, self-hostable option exists, tell me about it before recommending a subscription. ``` That last section is not a small thing. Left alone, an agent will happily recommend a $99/month service to solve a problem a free tool solves in ten minutes. Put the constraint in the file and it stops happening. ## The permission problem Out of the box, the agent asks before running commands. Good. But it asks about *everything*, including reading a file and listing a folder, and after the fortieth prompt you are clicking approve on autopilot without reading. Now the safety check is worse than useless — it's giving you a false sense that you're reviewing things you aren't. **Figure: Where to draw the permission line** The answer is not to disable permissions. It's to draw the line in the right place: | Let it run freely | Always stop and ask | |---|---| | Reading files. Listing folders. Searching text. Checking status. Viewing logs. Running tests. Anything that **looks** but doesn't **touch**. | Deleting anything. Sending an email or a message. Pushing to a live site. Spending money. Changing DNS. Restarting a service people depend on. Anything you can't undo. | The principle in one line: **if it's reversible and it doesn't leave the building, let it run.** If it's permanent, outward-facing, or expensive, it stops and asks you. That's the same rule you'd give a new hire on their first week. In Claude Code, you set this with the `/permissions` command, which lets you add specific commands to an allowlist. Add the safe read-only ones as you hit them. Within a week the prompts drop to almost nothing, and the ones that remain are the ones you should actually be reading. > **Don't take the shortcut** > > There's a flag that turns off permission checks entirely. It is tempting and you should not use it on a server that matters. The whole point is that the prompts you still get are the ones worth stopping for. Turn them all off and you've just handed a stranger your keys and gone to bed. ## The habit that makes this compound Every time you correct the agent — "no, I told you not to use jargon," "no, always commit first," "no, we don't pay for scrapers" — **don't just say it. Put it in the file.** A correction you make in conversation is gone the moment the session ends. A correction you write into `CLAUDE.md` is permanent. My file is now a couple of pages long, and every line in it is a mistake I only had to fix once. That's what makes this thing get better over months instead of resetting to zero every morning.