Most AI guides stop at the chat box.
This one starts at a blank hard drive.

./start-here.sh

where are you right now?

Each path stands on its own. Start at the one that matches you and stop whenever you have enough.

~/paths/0-blank-machine

[0] install ubuntu

You do not need Linux to use AI. You need it for the version of this where models run on your own hardware, nothing is metered, and nothing leaves the building unless you send it.

1. Back up anything you care about first

   Installing an operating system erases the drive you install it on. This is the step people skip and the only one that is unrecoverable.

2. Download Ubuntu LTS

   Take the LTS release, not the newest one. LTS means long term support: five years of security updates and far fewer surprises. Take whichever LTS is current when you read this.

3. Write it to the USB stick

   Use a tool that makes the stick bootable rather than just copying the file onto it. Balena Etcher and Rufus both do this and both are free.

4. Boot from the stick

   Restart with it plugged in and press the boot-menu key during startup — usually F12, sometimes F2, Esc or Del. Pick the USB device.

   If it boots straight back into your old system, the boot menu key was wrong or Secure Boot is refusing it. Both are settings in the same firmware screen.

5. Choose "Try Ubuntu" before "Install Ubuntu"

   It runs entirely from the stick and changes nothing. Confirm your wifi, your screen and your trackpad all work before you commit to installing. Five minutes here saves a bad afternoon.

6. Install it

   Take the defaults unless you have a reason. Say yes to third-party drivers when asked — that is what makes graphics and wifi work.

7. Update everything, then reboot

   # fetch the current package lists, then apply every update
   sudo apt update && sudo apt upgrade -y

   You will be asked for the password you just set. It will not show anything as you type it. That is normal and not a broken keyboard.

~/paths/1-install-claude

[1] install claude code, and know which claude is which

"Claude" is several different products and people lose a lot of time installing the wrong one. Here is the whole map.

1. Install it

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

   It lands in ~/.local/bin/claude. Nothing else is required — no Node, no npm, no package manager, no build tools.

   Older write-ups tell you to install Node and use npm. That path still exists and it is no longer the simple one. This machine has no Node installed at all.

2. Check it is on your PATH

   claude --version

   If the shell says "command not found", close the terminal and open a new one, then try again. If it still fails, add the folder to your PATH:

   echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc && source ~/.bashrc

3. Sign in

   claude

   First run opens a browser to authenticate. After that it remembers.

4. Point it at a folder and try something real

   Claude Code works inside whatever directory you start it in, and it can see the files there. Make a folder, go into it, start it, and ask it to create something. Watch the file actually appear.

   That moment — a real file, on your real disk, that you did not type — is the entire difference from a chat window.

~/paths/2-give-it-a-memory

[2] give it a memory it does not lose

By default every conversation starts from nothing. It does not know your projects, your decisions, or anything it worked out yesterday. That is the single biggest thing standing between a novelty and something useful.

The fix is unglamorous: a folder of plain text files that it reads at the start of every session and writes back to as things change. Not a database, not a plugin. Markdown files in a folder.

why obsidian

Obsidian is a free app that reads a folder of markdown files. It is not required — the files are just files, and Claude Code can read them without it. What it gives you is a way to see and navigate the memory yourself, which matters because you need to be able to check what your assistant believes.

1. Install Obsidian

   sudo snap install obsidian --classic

   The --classic flag matters: without it the app is confined and cannot read folders elsewhere on your disk, which defeats the point. Install it this way rather than through a store package.

2. Make the folder, and open it as a vault

   One folder somewhere sensible, such as ~/Documents/brain. In Obsidian, "Open folder as vault" and point it there.

3. Write the one file that matters

   An index at the root — who you are, what you are working on, and the rules you want followed. This is what a new session reads first. Keep it short enough that you would actually read it yourself.

4. Tell Claude Code the folder exists

   Put a CLAUDE.md file in the directory you start it from, pointing at the vault and saying to read the index at startup. That file loads automatically every session.

   From then on it opens knowing who you are.

5. Make it write things down

   The half people skip. A memory that is only ever read goes stale in a week. The instruction that matters is: when something changes that a future session would need to know, write it to the vault without being asked.

~/paths/3-connect-it

[3] connect it to your real things

Mail, calendar, documents. This is where it stops being a clever toy, and it is also the point at which the questions get serious.

what connecting actually means

You are granting a program the same reach into an account that you have. Not a copy, not a summary — the real thing. That is exactly why it is useful, and exactly why it deserves a minute's thought per connection rather than clicking through.

the rule worth adopting before the first one

Connect one service. Use it for a week. Then decide whether the next is worth it. The failure people regret is not one bad connection, it is granting six on a Sunday afternoon and never revisiting any of them.

there are two different routes, and people confuse them

Both end up in the same place. Whatever you connect either way shows up in one list, which is the command worth learning first.

1. See what you already have

   claude mcp list

   It prints every connected service and checks each one is actually answering. On this machine it returns three, all reporting connected:

   claude.ai Google Calendar: … ✔ Connected
   claude.ai Gmail:           … ✔ Connected
   claude.ai Google Drive:    … ✔ Connected

   Run this first, and run it again any time something stops working. "Connected" versus silence is the fastest way to tell a broken connector from a broken instruction.

2. Add the ready-made ones in the browser

   Mail, calendar and files are set up in Claude's own settings under Connectors, not from the terminal. You sign in to the account you are granting access to, and it appears in claude mcp list afterwards.

   Connect one. Then stop and use it for a week.

3. Add anything else from the terminal

   For a service that hosts its own endpoint:

   claude mcp add --transport http <name> <url>

   If it needs a key, the key travels as a header rather than sitting in the URL, where it would end up in your shell history:

   claude mcp add --transport http <name> <url> \
     --header "Authorization: Bearer <token>"

   And for one that runs as a local program instead of a web service:

   claude mcp add <name> -e API_KEY=xxx -- <command>

4. Check it took

   claude mcp list

   If the new one is missing or not reporting connected, fix that before going further. A half-attached connector fails in ways that look like the assistant being stupid rather than the plumbing being wrong.

This is not theoretical and it is not rare. It is the single most likely way a genuinely useful setup turns into a problem, and it costs nothing to rule out on the first day.

~/paths/4-your-own-hardware

[4] run models on your own hardware

Everything up to here has been metered — you pay per use. This is the part that is not.

the one number that decides everything

Not your system memory. The memory on your graphics card. A model has to fit in there to run at a usable speed. If it does not fit, it either refuses to load or spills into system memory and slows by roughly ten times, which in practice means unusable.

what belongs on your own machine

Anything high-volume and low-difficulty: transcription, speech, routing, classification, summarising, and anything touching data you would rather not send anywhere. These are precisely the jobs that generate an alarming bill when metered, and precisely the ones a small local model handles well.

what still justifies paying

Long reasoning, large context, code that has to be right, and anything where being wrong is expensive. A frontier model is meaningfully better at these, and pretending otherwise is how people end up disappointed in local AI and blaming the wrong thing.

~/paths/5-what-you-need

[5] what it takes to run this

The binding constraint is graphics memory. Everything else is comfort. A model has to fit on the card in one piece — if it does not, it either refuses to load or spills into system memory and slows down by an order of magnitude.

why those numbers

8 GB of graphics memory is the floor, and it is a real floor. A 2–4B model quantised sits around 2–3 GB and leaves room for the context window, which grows with the length of the conversation and is the thing people forget to budget for. Under 8 GB you are choosing models by what fits rather than by what is good.

16 GB is where it stops being a compromise. A 9B model quantised is about 6.5 GB, so 16 GB runs it with genuine headroom — a long context, speech-to-text alongside it, and no swapping when something else wants the card.

24 GB is what a 30B-class model needs, and it fits with little to spare. That is the ceiling on a consumer card today, not a comfortable cruise. If your work does not need a model that size, the money is better spent on memory and a fast disk.

System memory matters more than people expect, because the model is not the only thing running. Speech-to-text, text-to-speech, the web services and the editor all want their share. 16 GB works. 32 GB means you stop thinking about it.

Storage is about patience, not capacity. The models below total roughly 40 GB, so 100 GB is enough to start. But a model is read off disk every time it loads, and on a spinning disk that is a wait you will feel every single time. NVMe is the upgrade you notice most per pound spent.

NVIDIA, and this is not brand loyalty. The tooling in this space is built on CUDA first and everything else second. AMD and Apple silicon both genuinely work and both cost you time in setup and in finding help when something breaks. If you are learning, spend that time on the work instead.

One caution from experience: a brand-new card can be ahead of the software. A card released weeks ago may have no matching build in the standard toolkits yet, and you can end up compiling things yourself to use hardware you already paid for. Last generation is often the smoother purchase.

models installed locally

All quantised — compressed to fit consumer hardware at a small and usually unnoticeable cost in quality. Unquantised, most would not fit on this card at all. That trade is the most useful thing to understand before picking a model.

the assistant, in pieces

What people picture as "an AI" is several separate services, each doing one job. Splitting them is what makes it fixable when it breaks.

Four of those six never touch the internet. That is a privacy answer and a cost answer at the same time, and it is why the split is worth the setup.

~/updates

sign up for updates

This page gets added to. New paths, corrections when something on it stops being true, and the occasional write-up of something that broke and what it took to fix. If you want to know when that happens, leave an email address.

This box posts to this site and nowhere else — no mailing platform, no embedded widget, nothing loaded from another domain. Same claim as the rest of the page, and the same one you can check by reading the source.