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.

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: Anthropic now supports native Windows installs, but WSL2 (Windows Subsystem for Linux) is the recommended path — it matches the Linux conventions your production server will run on later. Open PowerShell as admin, run wsl --install, reboot, then open the Ubuntu app from your Start menu. (Skip-WSL is possible: install from PowerShell directly via irm https://claude.ai/install.ps1 | iex. Works for getting started, but you'll likely hit friction once you deploy.)
• Linux: you already know.

Install Claude Code

Paste this into your terminal:

# Mac, Linux, or WSL on Windows:
curl -fsSL https://claude.ai/install.sh | bash

Windows users who skipped WSL2 (rare but supported) can install natively from 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. If you see "command not found," see troubleshooting below.

Now sign in by just running:

claude

This launches Claude Code. On first run 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 → close your terminal, open a new one. The install added Claude Code to your PATH but the existing terminal session doesn't know about it yet. Fresh window picks it up.
• 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.
• Still stuck after a fresh terminal → run claude doctor. Anthropic ships a built-in diagnostic that checks your install, PATH, permissions, and config, and prints exactly what's wrong.
• 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). Upgrade to Max 5x ($100/month) the moment you're running an orchestrator that fires agents on a schedule. Upgrade to Max 20x ($200/month) when you ship to production and the agents run 24/7.

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.

Paste this into your terminal:

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

What you 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 when you run claude in this folder

Open CLAUDE.md in your editor and paste this:

# 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 with your version. Save.

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 8), 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.

Steps

1. Create a GitHub account at github.com if you don't have one (free).
2. Create a new private repo. Click the + in the top-right → New repository. Name it my-research-agent (or your project's name). Private so your .md brain files and ICP criteria don't leak. Don't initialize with a README; you already have one locally.
3. Generate a Personal Access Token (PAT) for HTTPS pushes. GitHub removed password authentication for git in 2021; you'll need a token instead. In GitHub: Settings (your profile, top-right) → Developer settings → Personal access tokens → Tokens (classic) → Generate new token (classic) → give it a name like "laptop git push" → check the repo scope → Generate. Copy the token (starts with ghp_...) somewhere safe; you won't see it again. You'll paste this in place of your password the first time you push.
4. Connect your local project to the GitHub repo. GitHub shows you the commands on the empty-repo page. They look like this (replace YOUR-USERNAME):

cd ~/my-research-agent
git remote add origin https://github.com/YOUR-USERNAME/my-research-agent.git
git branch -M main
git add .
git commit -m "Initial commit: agent scaffold per Altitude Playbook"
git push -u origin main

5. When prompted for username + password during git push: enter your GitHub username, and for the password paste your Personal Access Token from step 3 (NOT your GitHub password — that won't work). Most systems remember it after the first push.
6. Verify on github.com — refresh the repo page. Your files should be there.

(Alternate path: install GitHub CLI, run gh auth login, follow the browser prompts. Replaces the PAT step entirely with OAuth.)

How to use it going forward

After any meaningful change to your agent (new memory file, CLAUDE.md update, correction added to feedback-learned.md):

git add .
git commit -m "what changed, in one line"
git push

Three lines. Takes 5 seconds. Run it at the end of every working session as habit. Your backup stays current; your version history compounds.

One important: never commit your .env file. It has any API keys you'll later add. The next steps in the full playbook show you how to safely manage that.

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)

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

That's the next 7 sections of the playbook.

What's in the full playbook

The setup you just did is Step 0. The methodology starts in Section 2:

• Section 1 (paid): the why behind every choice in this setup — what an agent actually is (loop + state + tools + memory + decisions), the pressure→hallucination principle (the single most important methodology insight), why this stack vs alternatives (Cursor / Antigravity / Codex / frameworks / OpenClaw / Hermes), how the cost model makes the whole thing economically viable, the real economics of subscription vs API. Sets up everything that follows.
• Section 2: build your first agent (Scout) end-to-end — memory files, CLAUDE.md, Supabase tables, first correction loop.
• Section 3: memory in depth — how to structure the brain so it scales past one agent.
• Section 4: the state machine — gate checks, status fields, the contract between agents.
• Section 5: second agent (Sage) + the orchestrator — multi-agent coordination, the watcher script, terminal vs cloud handoff.
• Section 6: the QA agent (Warden) — adversarial review, bounded revision loops, the flagship pattern that closes the trust gap.
• Section 7: the improvement loop — how corrections compile into structure, feedback becomes rules, the system gets sharper over time.
• Section 8: deploy + ship — production checklist, monitoring, what to do when something breaks.

Get the full playbook → Founding 100 · $149 lifetime

Includes: 8 sections + 30+ paste-ready prompts + live AI assistant trained on the playbook + private #founders Discord + first access to v2.