Setup Guide: install Claude Code + scaffold the project folder

Free standalone install guide. The full Altitude Playbook teaches the methodology around this setup; this guide gets you to a working install. ~30 minutes start to finish.

Before you start

Quick orientation if you've never done anything like this.

The terminal is a text window where you type commands instead of clicking buttons. It looks bare and a little intimidating. That's normal. Mostly you'll copy a command from this guide, paste it in, and press Enter.

Claude Code is what you're installing: an AI that runs inside that terminal and builds alongside you.

What to expect:

• About 30 minutes, most of it paste-and-wait.
• Getting stuck is normal, not a sign you broke something. Every common snag has its fix right here in the guide.
• Something on your screen looks different from the guide? Use the help bot in the corner. Paste it exactly what you see and it'll tell you the next move.

That's the whole game. Let's go.

Open your terminal

If you've never opened a terminal before, that's fine. The next 5 minutes are the technical part. After that, the rest is mostly paste-and-iterate.

• Mac: Cmd+Space, type Terminal, hit Enter. A window with text appears. That's it.
• Windows: open the Ubuntu app you set up just above. That's your terminal from here on.
• Linux: you already know.

Install Claude Code

On Mac, Linux, or WSL on Windows, paste this into your terminal:

curl -fsSL https://claude.ai/install.sh | bash

On Windows without WSL2 (rare but supported), paste this into PowerShell instead:

irm https://claude.ai/install.ps1 | iex

This downloads + installs the CLI (Command Line Interface, the text-based way of running programs from your terminal). Verify it landed:

claude --version

You should see a version number like 2.1.89.

Now sign in by just running:

claude

This launches Claude Code. On first run it asks a couple of quick setup questions (such as choosing a color theme) and, if you're in a folder that already has files, whether you trust the files in this folder. Trusting just means you're letting Claude Code read and work with what's there, so highlight Yes and press Enter (it's your own machine). Then it opens a browser to sign you in with your Anthropic account. If the browser doesn't open, copy-paste the URL the terminal prints into any browser. After you authorize, the terminal confirms and drops you into the interactive session.

Common errors + fixes

• command not found: claude after install → see the highlighted box right under the install step above. It's the one step most people scroll past (close and reopen your terminal, then the shell-correct PATH line).
• bash: curl: command not found (rare, mostly on minimal Linux installs) → install curl first: sudo apt install curl (Debian/Ubuntu) or brew install curl (Mac).
• Permission denied during install → don't sudo the install command. Claude Code installs to your user directory, not system-wide; sudo will mess up the file ownership.
• Sign-in browser doesn't open → copy the URL printed in your terminal, paste into any browser, sign in there. The CLI watches for the auth handshake and confirms when complete.
• claude runs but something else is wrong (anything other than command-not-found) → run claude doctor. Anthropic ships a built-in diagnostic that checks your install, PATH, permissions, and config, and prints exactly what's wrong. (This needs claude to already be findable, so it's for an installed-but-misbehaving CLI, not the PATH error above.)
• Anything else → check the Claude Code setup docs for the current install method; Anthropic occasionally updates the install path.

If you got claude --version to print a version number, you've cleared the highest technical bar in this whole setup. The rest is mostly paste-blocks.

What Claude Code costs

Important: the free Claude.ai plan does NOT include Claude Code access (Anthropic confirms this in their setup docs). You need at least Pro to use it. Three paid tiers:

• Pro ($20/month, or $17/month billed annually at $200/year). Same monthly price as Cursor Pro. Gives you real Claude Code access for individual development. Start here if $20 is the comfort threshold. You'll outgrow it once your agents run sustained work, but it's the lowest-friction on-ramp.
• Max 5x ($100/month). What most builders running real agent systems land on. 5x the Pro quota. The right tier the moment you start running cron-invoked agent processes through the day.
• Max 20x ($200/month). For sustained heavy multi-agent loads. Where the economics versus raw API billing become dramatic (the full playbook explains this in detail).

Practical recommendation: start on Pro ($20/month) for the learning phase. Move to Max 5x ($100/month) when you ship the team to a server and an orchestrator fires the agents on a schedule; that is the tier a running team lands on. Max 20x ($200/month) is for when the load actually outgrows that (several always-on agents working real volume), and by then you should be charging clients enough to cover it. Section 11 has the full math.

Three ways to actually run your agents (and why this playbook picks one):

• API. Your code calls Anthropic directly and you pay per token used. Scales infinitely, but running agents all day on top models adds up fast. The metered taxi.
• Subscription (what this playbook uses). A flat monthly fee, and you work inside a live, interactive Claude Code session. Keep one running and drive your agents through it, and you stay on that flat rate no matter how hard they work. This is the cheap edge the whole playbook is built on.
• -p (headless). A one-shot command mode that runs with nobody at the keyboard, which is what makes scripting and cron possible. It rides the subscription today. Anthropic has announced a change (currently postponed, with advance notice promised before it takes effect) that would meter -p and the Agent SDK into a separate monthly credit. Until that lands, headless still bills on your flat subscription, and the persistent-session design keeps you safe whenever it does.

The persistent, interactive session is what keeps your costs flat. Section 11 of the full playbook has the complete money math.

Set up your project folder

The agent lives in a folder on your laptop. Eventually it'll live on a server, but during the build it's local so you can iterate fast.

First, create the folder and open Claude Code inside it. (That ~ you'll see is just shorthand for your home folder, so ~/my-research-agent means a folder called my-research-agent in your home directory.) Paste this in:

mkdir -p ~/my-research-agent
cd ~/my-research-agent
claude

mkdir makes the folder, cd ("change directory") moves you into it, and claude launches Claude Code right there. You're already signed in from the install step, so it goes straight in. If it asks whether you trust the files in this folder, highlight Yes and press Enter.

Let Claude Code build the scaffold for you

You're now inside Claude Code, in your project folder. Don't build the structure by hand. Creating folders and files is exactly the kind of deterministic work it does perfectly. Tell it, in plain words:

Set this folder up as the scaffold for an agent project. Create agents/, memory/, and scripts/ folders. Initialize git. Then create CLAUDE.md and README.md, and write a short starter CLAUDE.md for a research agent for [your business] whose job is [one sentence: what does the agent do?].

Fill in the two brackets with your own answers. Claude Code works from the facts you give it (it won't invent your business), creates every folder and file, and writes the starter CLAUDE.md for you.

What it just made:

• agents/, one subfolder per agent (you'll create the first one in the playbook's Section 2)
• memory/, the .md files that are the brain
• scripts/, the cron-driven orchestrator (Section 5 in the full playbook)
• CLAUDE.md, the top-level instructions Claude Code reads every time you run claude in this folder
• a git repo, so your work can be saved and backed up (the next step)

Prefer to do it by hand?

If you'd rather set it up yourself, paste this instead of asking Claude Code:

mkdir -p ~/my-research-agent
cd ~/my-research-agent
git init
mkdir agents memory scripts
touch CLAUDE.md README.md

Then open the empty CLAUDE.md to paste into it. Run the line for your system:

• Mac: open -e CLAUDE.md (opens it in TextEdit)
• Windows (WSL2, the recommended path): notepad.exe CLAUDE.md (opens Windows Notepad; the .exe matters, plain notepad won't work inside WSL)
• Windows (native PowerShell or CMD): notepad CLAUDE.md
• Linux desktop: open it in your text editor, e.g. gedit CLAUDE.md

With the file open, paste this in:

# This project: a research agent for [your business]

The agent's job is [one sentence, what does the agent do?].

It writes structured signal to Supabase. The QA agent checks every output before it's surfaced to a human.

When working in this folder, you are helping me build, debug, or
extend this agent system. Follow the patterns established in the
agent CLAUDE.md files under agents/. Don't invent new patterns
unless asked.

Fill in the two bracketed placeholders ([your business] and the one-sentence agent job) with your own version. Then save the file: Cmd+S on Mac, Ctrl+S on Windows or in WSL Notepad. Close the editor window. Back in your terminal, you're ready for the next step.

Set up GitHub (your backup + deploy bridge)

You ran git init above, which creates a LOCAL version-control repo on your laptop. That alone isn't enough. GitHub (the hosted version of git) does three jobs that matter:

1. Backup of everything. Your agent system is in this one folder. Laptop drowns in a coffee, dies, gets stolen. Without GitHub, you've lost all your .md memory files, all your prompts, all your agent corrections. With GitHub, it's a git clone to restore on any new machine. Cheapest insurance you'll ever pay (free for private repos).
2. Version history. Every time you commit, you save a snapshot. If you break your agent at 2am, git log shows you exactly what changed and git revert undoes it. Pre-LLM ops discipline that's even more important when LLMs are writing parts of your code.
3. The bridge to your production server. When you ship to production (covered in the full playbook's Section 10), the server pulls your code FROM GitHub via git clone. Without GitHub in the middle, there's no clean path from your laptop to the server.

Let Claude Code set it up for you

You just installed an AI that runs commands for you. Use it. You don't have to create repos, generate tokens, or run git by hand.

Open Claude Code in your project folder:

cd ~/my-research-agent
claude

Then tell it, in plain words:

Set up a private GitHub repo for this project and push everything to it. Walk me through anything you need from me.

Claude Code installs the GitHub command-line tool if it's missing, creates the private repo, and pushes your project up. It runs the commands so you don't have to.

Saving your work going forward

After any real change (a new memory file, a CLAUDE.md edit, a correction you added), just tell Claude Code:

Save my work to GitHub.

It commits and pushes for you. Prefer to do it yourself? These three lines do the same thing from your terminal:

git add .
git commit -m "<short description of what you just changed>"
git push

Never commit your .env file. It holds any API keys you add later. (An API key is basically a password that lets your code use a paid service, like a database or an AI model. You'll set these up in the playbook; for now just know they live in .env.) Claude Code knows to keep it out of git; if you ever push by hand, leave .env alone. The full playbook shows you how to manage it safely.

Prefer to do it by hand?

If you'd rather not use Claude Code for this, or it gets stuck:

1. At github.com, create a new private repo named my-research-agent. Don't initialize it with a README; you already have one locally.
2. GitHub then shows a "push an existing repository from the command line" box. Copy it, paste it into your Terminal, press Enter.
3. When git push asks for a password, it wants a Personal Access Token (PAT), a special password GitHub creates for you that proves you own the account without exposing your real one, not your GitHub password (GitHub dropped password auth in 2021). Generate one at GitHub → Settings → Developer settings → Personal access tokens → Tokens (classic), give it the repo scope, and paste that token as the password. (The terminal won't show anything as you paste it. That's normal, not a freeze. Just press Enter.)

Stuck on any of it? The help bot in the bottom corner walks you through each step.

Set up Supabase (your agents' database)

Your agents store everything they do, every signal, every draft, every QA verdict, in a database. We use Supabase. Set the project up now so it's ready the moment you build your first agent.

First, create the project. This part happens on Supabase's website, not something Claude Code can do for you:

1. Go to supabase.com, sign up, create a new project: name it whatever you want, pick the region closest to you, generate a database password (save it to a password manager, you'll rarely need it).
2. In the project dashboard: Settings → API Keys → under the "API Keys" tab → copy the secret key (starts with sb_secret_...). Also copy the Project URL at the top of the same page.

There are two ways into your database, and you'll set up one now and one later. It's worth understanding why, because it's the thing people find most confusing about this stack.

• Your agent sessions (Claude Code, working alongside you) reach Supabase through a connection you approve once with a login. No keys pasted, no secrets in files. This is the one you set up now.
• The orchestrator script you build in Section 5 is a plain script, not a Claude Code session, so it can't use that login. It reads the secret key from a .env file instead. You'll set that up in Section 5, and Section 10 copies it to your server.

Set up the connection now, so your agents can read and write the moment you build them. Open Claude Code in your project folder and tell it, in plain English:

"Connect Claude Code to my Supabase project so you can read and write my database directly. Walk me through anything you need from me."

Claude Code sets up the Supabase connection and pauses for the one thing only you can provide (Supabase shows it a token to authorize the link, the same one-login pattern as GitHub). When it's done, confirm it worked by asking:

"Can you read and write my Supabase database?"

It runs a quick check (it may write and delete a tiny test row) and comes back with a plain yes, naming your project. That yes is exactly what Section 2 of the playbook expects before you build your first agent.

Hold onto the secret key for Section 5. You don't need to paste it anywhere yet. Just keep the Project URL and the sb_secret_... key somewhere safe (your password manager), and Section 5 walks you through putting them in a .env file for the orchestrator script. If you'd rather stash them now, ask Claude Code to create a .env with SUPABASE_URL and SUPABASE_SECRET_KEY and add it to .gitignore, and paste the values into the file yourself, never into the chat.

Note on the key system: Supabase moved to sb_publishable_... / sb_secret_... keys in late 2025. The older anon + service_role JWT keys are deprecated; new projects created from Nov 2025 onward don't include them by default. If you find an older tutorial referring to service_role, the modern equivalent is sb_secret_..., and that secret key is the one the orchestrator script uses to read and write the database on its own in Section 5.

Two Free-tier gotchas to know upfront:

• Free projects auto-pause after 7 days of inactivity. If you set up Supabase today and don't touch it until next week, you'll find your project paused. Click "Restore" in the dashboard, takes ~30 seconds, no data loss. Once you have agents writing to it daily it never pauses.
• Free tier allows 2 active projects max. If you already have other Supabase projects, pause one in its Settings to free up a slot.

You'll create the actual database tables in Section 2 of the playbook; for now you just need the project to exist.

Closing the terminal and coming back later

You don't keep the terminal open forever. Close the window whenever you need to do other things. Your work is safe on disk, and on GitHub once you've pushed. Coming back is two steps:

1. Open your terminal again (Cmd+Space → Terminal on Mac; the Ubuntu app on Windows/WSL) and run claude.
2. Just tell it where to go, in plain words:

Navigate to my project, the folder called my-research-agent, and let's keep working.

Claude Code finds the folder and starts working there. You're chatting with it, same as always. No paths to memorize.

How to know it worked: ask "what is this project?" Claude Code reads your CLAUDE.md and describes your research agent back to you. That's your confirmation it's in the right folder. If it ever asks whether you trust the files in the folder, that's just a fresh session. Highlight Yes and press Enter.

(Prefer the manual way? cd ~/my-research-agent then claude does the same thing, it just opens Claude Code already inside the folder.)

A few habits worth picking up

Once the daily ritual feels natural, a few small things make working with Claude Code smoother.

Switching to a totally different job? Type /clear. It starts a fresh conversation with empty context, while keeping your project memory (your CLAUDE.md). Use it when you finish one task and start an unrelated one, so the last job doesn't bleed into the next. Your old conversation isn't lost, /resume brings it back.

Same job, but the chat's getting long? Type /compact. It summarizes the conversation so far to free up room without losing your place. Rule of thumb: /clear for a new task, /compact to keep going on the current one.

Keep feeding the memory. Whenever you teach Claude Code something that should stick, how you like things done, a decision you made, a fact about your business, tell it to save that to your CLAUDE.md. The agents are only as sharp as the memory you build. (And after a real change, just say "save my work to GitHub" so it's backed up.)

Plugins and skills: teaching it new tricks. A skill is a saved procedure, a checklist or multi-step job you write once so Claude Code uses it when it's relevant (or you call it with /its-name). A plugin bundles skills together to share. Type /plugin inside Claude Code to browse and add them. Not a day-one thing; they're there when you want to package up something you do often.

MCPs: connecting Claude to your other tools. An MCP is a bridge between Claude Code and an outside tool, your email, a database, Slack, so the agent can read and act there instead of you copy-pasting. You add one from the terminal, for example:

claude mcp add --transport http notion https://mcp.notion.com/mcp

Each tool gives you its own line to paste. Once it's connected, you just tell your agent "check my email" and it can.

What you've built so far

Take a breath. You've got:

• Claude Code installed and authenticated
• A project folder with the scaffold (agents/, memory/, scripts/, CLAUDE.md)
• GitHub backup configured (free for private repos, your work is now safe)
• A Supabase project, connected to Claude Code so your agents can read and write it (the secret key set aside for the orchestrator script in Section 5)

Nothing is doing real work yet. The agent doesn't exist. The brain is empty. The orchestrator hasn't been written.

Let's change that right now, before you read another word.

Your first prompt: introduce Claude Code to your business

Here's the moment most people freeze: everything's installed, the terminal's blank, and you don't know what to type. So type this.

It makes Claude Code read your website, tell you what it understood about your business, draft who your best-fit customers actually are, then build and run your very first agent, so you walk away with two or three real leads. Before you've read a single page of the Method.

First, make sure you're inside your project folder (the my-research-agent folder you made earlier). If you closed the terminal, reopen it, run claude, and tell it "go to my my-research-agent project."

Now fill in the bits in brackets. Rough answers are fine.

• Your name and company + website, so it knows who you are and can read your site.
• What you sell and who you sell to, a sentence each.
• What outreach you do today (cold email, LinkedIn, referrals, or nothing yet).
• Anything else worth knowing is optional. A recent win, a favorite customer, a deal you just closed. Leave it blank if you want.

Then paste the whole thing into Claude Code:

I'm building my own AI sales-agent team by following the Altitude playbook. Before we build anything, I want you to get a real feel for my business. Here's me:
- Name: [YOUR NAME]
- Company and website: [COMPANY], [WEBSITE URL]
- What I sell: [ONE OR TWO SENTENCES]
- Who I sell to: [YOUR IDEAL CUSTOMER, ROUGH IS FINE]
- Outreach I do today: [COLD EMAIL / LINKEDIN / REFERRALS / NOTHING YET]
- Anything else worth knowing: [A RECENT WIN, A KEY CUSTOMER, OR LEAVE BLANK]

Do this in order, and explain each step in plain English as you go (I'm not a developer):
1. Read my website. Actually fetch the page, and a couple of the main pages it links to like an About or product page. Then tell me, in your own words, what my business does, who my best-fit customers are, and how I talk about what I do. If a page won't load or something's unclear, tell me, don't guess.
2. From what you read, draft my ideal-customer profile as a SITUATION, the trigger or pain that makes someone a great fit right now, not just an industry or a job title. Show it to me and ask me to correct it.
3. Once I confirm the profile, scaffold my first agent: a finder that looks for companies matching my profile that have a fresh, real reason to be contacted right now. Put its instruction file and a memory file holding my profile inside the agents/ and memory/ folders we set up earlier.
4. Run the finder once on a small scale so I can SEE it work: bring me two or three real companies that fit, each with a fresh reason to reach out and a source link. For every link, actually open it: confirm it loads (not a dead page or a 404) AND that the reason is still current. A job post should be from the last few weeks, not two years ago; a funding round, news item, or product launch should be recent. If the only proof you can find is stale, or you can't confirm it's still live, that trigger doesn't count, find a better one or tell me you came up short. Check every fact against the live page. Invent nothing.

Rules: keep explaining things simply, ask me before anything that changes files outside this project or costs money, and never make up a company, a fact, or a person. If you're unsure, ask me.

Two things tell you it's working, so you know what good looks like:

• Step 1 should sound like you. If it reads your site and hands back something generic ("you sell software to businesses"), tell it to be sharper, or add a line to "Anything else worth knowing." When it nails how you actually talk about your work, that's the signal.
• Every lead in step 4 has a source link you can click, and the reason is recent. That's the whole discipline of this system, verified and current, not invented or stale. A real link that's two years old isn't a reason to reach out today. If a claim has no live, recent source, it doesn't ship. You just watched your agent do the one thing most AI sales tools skip.

That's your first agent, running, before the Method has taught you a thing. The full playbook is how you make it sharp, add more agents, and put it on autopilot.

What's in the full playbook

The setup you just did is your on-ramp. The full playbook is two layers.

The Method, where you build your agent team:

• The why behind every choice (paid): what an agent actually is (loop + state + tools + memory + decisions), the pressure to hallucinate principle (the single most important methodology insight), why this stack vs alternatives (Cursor / Antigravity / Codex / frameworks / OpenClaw / Hermes), and the cost model that makes the whole thing economically viable.
• Your first agent (Ranger): build it end-to-end. Memory files, CLAUDE.md, Supabase tables, first correction loop.
• Memory in depth: how to structure the brain so it scales past one agent.
• The state machine: gate checks, status fields, the contract between agents.
• The second agent (Scholar) + the orchestrator: multi-agent coordination, the watcher script, terminal vs cloud handoff.
• The QA agent (Sentinel): adversarial review, bounded revision loops, the flagship pattern that closes the trust gap.
• The improvement loop: how corrections compile into structure, feedback becomes rules, and the system gets sharper over time.

The Build, where you deploy it and run it on any engine:

• Build it for real: provision the cloud server, deploy, connect a chat app, ship to production.
• The economics: what a five-agent system actually costs to run, and the one billing choice that decides whether it's $200/month or thousands.
• Engine glossary: the translation table for running the same agents on OpenClaw or Hermes instead of Claude Code.

Get the full playbook → Founding 100 · $149 lifetime

Includes: the full two-layer playbook + 30+ paste-ready prompts + a live AI assistant trained on it + private #founders Discord + first access to v2.