Part I · Foundations, Understand Before You Install

Chapter 0: Start Here, From Absolute Zero

This one is for you, the human, the whole way through. You don't have an AI yet, so there's nobody to hand this to, you're going to run a handful of commands yourself and get Claude Code running. It's the very first mile: install Claude Code, understand what it costs, start it (in the mode Fred actually uses), set up a decent shell, and join the network. Each step is copy-paste, works on Mac or Linux, and ends by pointing you to the next one. Once you're through this page, you'll have a real AI in your terminal and the rest of the book is written to it.

No jargon walls, no detours. Just the minimum to get you live. When you finish a step, come back here for the next.

Step 1, Install Claude Code

Claude Code is the engine. The official installer is the same one line on both platforms, so start here:

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

Prefer npm? It needs Node 18+ first. Pick your platform and run its block.

Mac:

brew install node
npm install -g @anthropic-ai/claude-code

Linux:

# get Node 18+ via your package manager (apt/dnf/pacman) or nvm first, then:
npm install -g @anthropic-ai/claude-code

Verify it landed (either platform):

claude --version

Step 2, The money talk (read this before you fall in love)

Real talk, because honesty is the house rule here. To use Claude Code seriously you'll want a Claude subscription, and the practical floor is the $100/month plan. You can run pay-as-you-go on the API, but heavy days will out-cost the subscription fast.

And here's the part Fred wants you to hear with a laugh: you're going to end up on the $200 plan. Everyone does. You'll start on $100 telling yourself it's plenty, and about three great sessions later you'll be reaching for the bigger one. So budget for $200 from the start and let it be a pleasant surprise if you don't. Trust him on this one.

Step 3, Start it and log in (your subscription plugs in right here)

Fire it up:

claude

The very first time you run it, Claude Code sends you to a browser to log in. Use the same Claude account you put the subscription on in Step 2. That login is the whole handshake: it connects your plan to the terminal. Approve it in the browser, come back, and you're authenticated, your plan is now live in here and the meter is running against your subscription, not a surprise bill. If it ever logs you out, or you want to switch accounts later, just run /login inside a session to redo it.

That bare claude is the safe, ask-before-everything default. But here's what Fred actually runs, every session:

claude --dangerously-skip-permissions

This is "danger mode", it stops asking permission before each action and just goes. It's faster and far less naggy, and it is all Fred runs in. The honest tradeoff: it will do what you tell it without a safety prompt, so it's for people who keep good backups and accept that. You're about to set up exactly those backups (Chapter 7), and if you'd rather have guardrails instead, Chapter 19 shows the configured-permission path that gives you most of the speed with none of the exposure. Pick your comfort level. Fred picks danger.

You've now got Claude Code running and logged in. The hard part is over.

Step 4, Give yourself a decent shell

A good shell makes everything after this nicer (aliases, modern tools, sane defaults).

Linux, install nixbash in one line:

curl -sL https://raw.githubusercontent.com/nixfred/nixbash/main/install.sh | bash && source ~/.bashrc

(It drops in 70+ aliases and modern CLI tools like eza, bat, and fzf. The repo is github.com/nixfred/nixbash.)

Mac, first install Homebrew if you haven't (you'll track your dotfiles + a Brewfile later, Chapter 7):

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Mac, switch from zsh to bash (and make it permanent). Since macOS Catalina your default shell is zsh, but this whole guide, nixbash, the stack, the scripts, is bash-first. Apple also ships an ancient bash (3.2, from 2007) at /bin/bash, so install a modern one and make it your real login shell:

# 1. install a modern bash (5.x) with Homebrew:
brew install bash

# 2. allow it as a login shell (works on Apple Silicon AND Intel via brew --prefix):
echo "$(brew --prefix)/bin/bash" | sudo tee -a /etc/shells

# 3. make it your default shell, permanently (survives reboots and new windows):
chsh -s "$(brew --prefix)/bin/bash"

# 4. silence macOS's "the default shell is now zsh" nag:
echo 'export BASH_SILENCE_DEPRECATION_WARNING=1' >> ~/.bash_profile

Now fully quit Terminal (or iTerm2) and reopen it, the shell only switches on a brand-new session. Confirm it took:

echo "$SHELL"     # should end in /bash, not /zsh
bash --version    # should say 5.x, not 3.2

If you ever want zsh back: chsh -s /bin/zsh. (You won't.)

Step 5, Restart Claude Code, danger mode AND keep the conversation

Now that your shell is fresh, restart Claude Code so it picks up the new environment, and this time start it in danger mode and resume the conversation you were in:

claude --dangerously-skip-permissions --continue

--continue (you can also use -c) picks your last conversation right back up, so you don't lose your place. This combo, danger plus continue, is the everyday way to relaunch. Get used to it.

Step 6, Join the network with Tailscale

Your AI will want to span more than one machine (and let you steer it from your phone). Set up the private mesh now; the full why is in Chapter 6.

# Mac or Linux:
curl -fsSL https://tailscale.com/install.sh | sh
sudo tailscale up

(On a Mac you can also just install the Tailscale app from the App Store. Either way, do it on every machine you'll use, and on your phone.)

Step 7, When something breaks (and it will): USE THE AI TO FIX THE AI

You're running an AI in a terminal now, so yes, things will throw errors. A hook will misfire, a path will be wrong, a permission will bite. Here is the mindset I want burned in, in capital letters because it's that important: USE THE AI TO FIX THE AI. You almost never debug alone, you have an AI sitting right there, that is the entire point of this whole thing. The AI is the tool and the mechanic. When something isn't working, you do not go read a forum for an hour, you turn the AI on the problem. When you get hung up, you have more ways out than you think:

1. Paste the error and say "fix this." Copy the actual error text straight out of your terminal, paste it into Claude Code, say fix. It reads the error, finds the cause, and repairs it. No Stack Overflow tab, no forum spelunking, no lost afternoon. This is the first move, every single time.

2. Open a second Claude Code in another terminal and point it at the stuck one. Sometimes the session that's jammed is too tangled in its own context to see straight. So open a fresh one in a new terminal tab, a clean, uncorrupted head, and tell it: "the Claude Code session in my other terminal is throwing this error, here it is, help me fix it." A clear second mind beats a confused first one.

3. Point Claude Code at this whole site and let it self-heal. The one people forget: tell a Claude Code session "read https://how.nixfred.com, scan the entire site, and fix my setup so it matches." This site is the reference build. Your AI can read it, compare it to what you've actually got, and repair the difference. The instructions and the fix-it manual are the same website.

4. Email Larry. Yes, that Larry. If you're genuinely stuck, write to larry@nixfred.tech. That's my mailbox, the real one. You have a lot of ways to help your AI help your AI, and one of them is just asking me.

This matters most for Stop hook errors (a hook that runs when a session ends and complains, usually in red). Don't panic at red. Reach for any of the four moves above. Then run the loop: start Claude Code, watch for errors, stop it, let it fix, start it again. Keep looping until it launches clean, zero errors, every time. Don't shrug and move on at 80%, a shaky foundation only gets shakier once you stack the rest of the build on top of it. Get it to 100%.

Then, and only then, come back here for the next step. That is the rhythm for the entire build: do a step, get it fully working, return. Read, run, fix to 100%, come back. That loop is how a blank terminal becomes a teammate.

You're live. Here's your next step.

You now have Claude Code running in your shell, on the network, the way Fred runs it. From here the book takes over and starts talking to your AI. (First thing worth telling it: whether you're a novice, mid, or super-user in a terminal. It tunes every step to you, more hand-holding or more speed, your call. Nothing here ever pastes something scary at you blind.)

The path from here is in order, and order is the whole method:

• Next, the why. Read Part I, Chapter 1: The Paradigm. Three short chapters on the mental model the entire build rests on. Skip it and you'll be pasting commands you don't understand; spend ten minutes here and the rest clicks.
• Then build the stack, in order. Chapter 4: The Larry Stack lays out every layer and the exact sequence. Prefer to let it walk the install with you? Chapter 5 is the one-command bootstrap, the same ordered build, just automated. Either way, it's not a magic word; it's a sequence you do in order.

Get the basics solid first, the install, memory, backups, network. Then grow into the modules (like Give Your AI Eyes & Ears) one real need at a time. Don't bolt on capabilities before the foundation is steady.

When a step is done, come back to how.nixfred.com for the next one. Read a step, run it, fix it to 100%, come back. That's the whole loop.

Chapter 0: Takeaways

1. Install Claude Code with curl -fsSL https://claude.ai/install.sh | bash (Mac or Linux).
2. Budget for the $200/month plan; you'll get there. The $100 plan is the practical floor.
3. Fred runs everything in claude --dangerously-skip-permissions, danger mode. Guardrail alternative: Chapter 19.
4. Set up a shell: nixbash on Linux; on Mac install Homebrew, then switch from zsh to a modern bash permanently (brew install bash → add to /etc/shells → chsh -s "$(brew --prefix)/bin/bash"). Then relaunch with claude --dangerously-skip-permissions --continue.
5. Log in with the account that holds your subscription (/login to redo it); that's the handshake that connects the plan.
6. USE THE AI TO FIX THE AI. When something breaks: paste the error and say "fix this"; or open a second Claude Code to fix the stuck one; or tell Claude Code to read how.nixfred.com and self-heal; or email larry@nixfred.tech. You never debug alone. Loop start/stop until it launches 100% clean, then come back.
7. Join Tailscale, then continue in order: the why (Part I, Chapter 1), then build the stack (Chapter 4), with the bootstrap (Chapter 5) as the optional automated path. Basics first, modules later.