The practical Claude Code guide

Most guides to Claude Code assume you are a developer. This one does not. If you run a business, a sales team, or a marketing function, this Claude Code guide walks you from "I have never opened it" to "my work runs on it", and explains the few concepts that actually matter along the way.

Claude Code is not a coding tool that happens to write text. It is a general assistant that can read, write, and change the files in a folder on your computer, and take multi-step actions on your behalf. The code part of the name undersells it. The useful mental model is closer to a very capable colleague who has read everything you gave them and never forgets where the files are.

What Claude Code actually is

A normal chat only works with the words in the conversation. Close the tab and the context is gone. Claude Code is different in three ways that compound:

• It works inside a folder on your machine, and can read and edit every file in it.
• It shows you a visual diff before it changes anything, so you always see exactly what it did.
• It can run many steps on its own, not just answer one message at a time.

That third point is the real shift. A chat is one round trip: you ask, it answers, you ask again. Claude Code can take a goal and run twenty or fifty steps toward it before it comes back to you, checking its own work as it goes.

The chat forgets you the moment you close the tab. Claude Code works inside your files, so it can actually build on what came before.

You reach it in a few places. The Claude desktop app is the main one, with a Code tab that covers almost everything. There is also a browser extension and a command-line version, but you do not need those to start. The official Claude Code docs are the canonical reference when you want the exact current behavior of a feature.

The setup that actually matters

The whole setup is two things, and only one of them is a real install.

1. The desktop app. Download it from claude.com/download, sign in, and you will see the Code tab in the sidebar. That is Claude Code. Claude Code needs a paid plan (Pro or one of the Max tiers); the free plan is chat only. See the current plans and pricing to pick one, and know you can start small and upgrade if you keep hitting limits.

2. Git. This is the one external tool you need. Git quietly tracks every change to your files, which is what gives you backups, history, and the ability to work as a team. On a Mac, open Terminal and type git --version; if it is missing, run xcode-select --install. On Windows, grab the installer from git-scm.com and accept the defaults. You will almost never touch Git directly; Claude Code drives it for you.

Two settings are worth changing on day one, both under Settings > Privacy: turn model training off, and turn web search and memory between conversations on. More on privacy near the end.

That is it. You do not need a terminal, a code editor, or any developer background. If you want a nicer way to preview the plain-text files Claude Code produces, a free markdown editor like Marktext, Obsidian, or VS Code is a pleasant addition, not a requirement.

The real unlock is context, not clever prompts

Here is the thing almost everyone gets backwards. People obsess over the wording of their prompt when the prompt is the small part. The output quality is decided mostly by what the AI already knows before you type anything. Prompt engineering is really context engineering.

There are three files that carry that context, and understanding them is 80% of getting value out of Claude Code.

CLAUDE.md is the operating system for a folder. Run /init in the Code tab and Claude Code creates it. This file is read automatically at the start of every session, so anything in it is context you never have to repeat: what the project is, how your company works, your tone of voice, your rules, your common commands. Think of it as onboarding a new hire once, instead of re-explaining the company every single morning.

personal.md tells the AI who you are: your role, what you produce, how you write. The easiest way to fill it is to type "interview me and write my personal.md", answer the questions, and let the file write itself. Ten minutes of conversation buys you an assistant that stops sounding generic, forever.

A knowledge base is the rest: a set of plain-text markdown files holding everything the AI should know about your business. Product, pricing, playbook, competitors, brand voice, case studies. If you are not sure where to begin, here is what to put in your company's AI memory first. The difference between a bare chat and one backed by a knowledge base is the difference between a stranger and a colleague who has worked with you for five years.

Bare chat starts every conversation from zero. A knowledge base means the AI starts every conversation already knowing your company.

Why markdown for all of this? Because plain text is the one format both humans and AI read perfectly, and it plays cleanly with Git so you can track every change. PDFs and spreadsheets are opaque by comparison. When you have existing material in other formats, just ask Claude Code to convert it: "turn this pricing PDF into a structured pricing.md". A good habit is to drop originals into a source/ folder and keep the working markdown in the root.

Making it repeatable: skills

Once you have done a task well, you should never have to explain it from scratch again. That is what a skill is: a saved set of instructions for a recurring task, invoked on demand with a slash command like /pitch or /recap. We cover this on its own in turn any repeated task into an AI skill.

The workflow is simple and it pays compound interest:

1. Do the task once, the long way, until you are happy with the result.
2. Say "save this workflow as a skill".
3. Next time, run the skill with just the new inputs.

The quiet power move is what I call the dual track. Every time you use the AI, you are working on two things at once: the task in front of you, and the system that does the next task. Wrong tone in an email? Update CLAUDE.md so it never happens again. New competitor? Add them to the knowledge base. Nailed a presentation? Save the workflow as a skill. The task is today's output; the update makes every future output better. Teams that internalize this get faster every week. Teams that skip it re-explain themselves forever.

Staying organized as the work grows

The more you use Claude Code, the more sessions you accumulate, and a pile of untitled conversations is its own kind of mess. Two habits keep it under control, and both borrow from how developers already think.

The first is forking. When you reach a good point in a session and want to try two directions without losing the current one, you can branch the conversation and explore both. It is the same idea as a branch in code: experiment freely, keep the version that works, throw away the one that does not, and the original is untouched. This is how you A/B two structures for a proposal or two angles for a launch, and pick the winner after you have seen both.

The second is housekeeping, never deleting. Rename sessions from "untitled" to something you will recognize in two weeks, group them by client or project, and archive finished work so it leaves your active list but stays searchable. Treat sessions like folders in an inbox: active is what you are working on now, archive is done-but-findable. You almost never need to delete anything, and deleting is the one move you cannot undo.

Making it autonomous: agents, modes, and connectors

Everything so far is you and Claude Code working turn by turn. The next level is letting it run on its own.

An agent takes a goal and works toward it without waiting for input on every step. "Research five competitors for this pitch" becomes one instruction, and the agent searches, reads, analyzes, and writes the summary itself. For bigger jobs it can even split work across specialized sub-agents running in parallel, like a small team, and combine the results.

You control how much freedom it has with modes, and the right instinct is to start cautious and loosen up as trust builds:

• Plan sketches what it intends to do before touching anything. Best for new or risky work.
• Ask answers questions without editing files. Good for research.
• Edits changes files but asks you to approve each change. A sensible default.
• Auto works independently and you review at the end. For when you trust the pattern.

For anything irreversible, deploying, deleting, sending something external, stay in Plan or Edits and read what it proposes before you approve.

Connectors are how Claude Code reaches beyond your folder to your other tools: Google Drive, Slack, GitHub, your CRM, design tools. They run on an open standard called MCP (Model Context Protocol), which you can think of as a universal plug for AI. You enable the ones you need under Settings > Connectors. The right order is to get your context and skills solid first, then add agents and connectors. Autonomy on top of a thin knowledge base just automates generic answers faster.

Running on a schedule: routines

An agent works when you start it. A routine works on its own, on a schedule, without your click. This is the shift from "I run the AI" to "the AI works for me in the background". Anything you do by hand every morning or every week, a summary, a report, a backup, is a candidate.

A useful distinction is whether the task needs thinking or is pure mechanics. A morning digest or a weekly client report needs the AI, so it belongs in a scheduled task that carries its own prompt. Copying, syncing, or checking files is mechanical, so it is better as a plain script with no AI involved: faster, and it costs nothing. And if something has to run even when your laptop is off, that is a job for a remote agent on a server rather than a local schedule.

The rule of thumb: any task you have done by hand three times is a candidate for a routine. Agents handle one-off work; routines handle the work that repeats.

Keeping it safe

None of this is worth much if you leak something you should not. A few habits cover the vast majority of the risk, and we lay them out for teams in the AI risks every manager should know.

• Turn off model training (Settings > Privacy), so your conversations are not used to train the model.
• Never paste real secrets into any AI: passwords, API keys, access tokens, personal data about real people. Use placeholders instead. The rule of thumb: do not type anything you would not write on a sticky note and leave on your monitor.
• Leave Claude Code in its default "ask" posture, where it requests permission before consequential actions, and actually read those requests instead of clicking through them. It can only write inside the folder you opened.
• Be extra careful with the browser extension. Do not grant blanket permission on sensitive sites like banking, email, or admin panels.

A knowledge base is for things like product descriptions, playbooks, public competitor analysis, and style guides. It is not for client contracts, real personal data, or internal financials. When something in it is sensitive, mark it so, and the AI can respect that boundary in what it puts into outputs or sends to Slack.

That marking is worth a moment on its own, because it is the same mechanism that makes everything above scale. Every markdown file can carry a small block of metadata at the top, called frontmatter: type, date, client, project, sensitivity, tags. It looks like this:

---
type: meeting
date: 2026-05-21
client: acme
project: web-migration
sensitivity: internal
tags: [migration, pricing]
---

With one consistent scheme, every document becomes structured data. The AI can pull "every meeting with this client in the last three months" with zero ambiguity, and the sensitivity field tells it what may or may not leave the building. Frontmatter is the quiet thing that turns a pile of files into a queryable, governable memory.

When your knowledge base grows itself

The biggest jump is when the knowledge base stops being something you feed by hand and starts growing as you work.

The clearest example is meetings, which we dig into in from meeting to memory. A meeting is recorded, the transcript is processed automatically, and the result is distributed to the right places: notes into a meetings folder, action items into tasks, observations about people where they belong. Five minutes after the call ends, the memory is updated and the follow-ups exist, with no manual entry. The same is true of action items in general: a line like "send the revised proposal by Thursday" can be extracted from a transcript into a task with an owner and a due date, and kept linked to the meeting, the project, and the people it involves. That linkage is the difference from a standalone to-do app, where a task sits in a silo with no memory around it.

This is the level where a personal setup starts straining against its own limits, which is exactly the seam worth understanding next.

From a personal setup to company memory

Follow this Claude Code guide and you will have something genuinely useful: a folder on your machine that knows your work, a set of skills, and an assistant that gets sharper every week. That is the right place to start, and for one person it can be enough.

The wall people hit is the jump from personal to organizational. Your knowledge base lives on your laptop. Your colleague builds a different one. Neither can see the other. When someone updates the pricing, the other five copies quietly go stale. And the moment you want your knowledge reachable from any AI client, not just your own Code tab, a folder on one machine is no longer the answer.

That gap, from a personal folder to a governed, shared, living memory every AI client can reach, is exactly what memrelay was built to close. Same plain-markdown knowledge you learned to build here, but hosted where your company controls it, updated through review instead of silent overwrites, and connected once so any AI can read from it. If the personal version already changed how you work, that is the shape of what it looks like for a whole team. We wrote about why generic AI keeps disappointing companies in why your AI doesn't know your company.

The takeaway is small and it is the whole game: the model is not your bottleneck, context is. Give the AI your knowledge in a form it can read, keep that knowledge yours, and the same model that felt generic yesterday starts working like it has been on your team for years.