TONY

I'm not a web developer. Never have been. Spend fifteen years in infrastructure and you'll know your way around a server rack, a routing table, and a runbook — but you'll have zero reason to ever touch CSS.

Yet, here you are, reading this on a site with my name on it. It didn't get here because I finally "learned to code." It got here because I treated a website like a plumbing project: I wired some boring, reliable pieces together until it stopped leaking.

The Stack: Zero Magic

I went pure static. No React, no Next.js, no build steps, and absolutely no node_modules folder bloating my hard drive like a digital tumor.

The whole site is just three files and a folder of photos. If you "View Source" right now, you're seeing the whole engine. No obfuscation. I wanted something I could open in a basic text editor at 2 a.m. and actually troubleshoot, because the person most likely to break this site is me.

The Pipeline: My Comfort Zone

This is the part that actually feels like my day job. It's a three-vendor relay race where everyone stays in their lane:

• Porkbun — cheap, honest domains without the "upsell" harassment.
• GitHub — where the code lives in a private repo.
• Vercel — the glue. I connected it to GitHub in five clicks.

Now, when I push a commit to main, Vercel grabs the files and pushes them live in under sixty seconds. It's a deployment pipeline that costs less per year than a decent steak dinner. That's how an infrastructure guy builds: boring parts, loosely coupled, easily replaced.

The "Secret" Sauce (Which is Just a Good Brief)

The catch? I didn't actually write most of the code. I wrote the brief.

I spent an hour in a blank doc spelling out exactly what I wanted. I didn't just ask for a "cool site." I demanded a specific vibe: gritty, cinematic, graphic-novel energy. Deep reds, navy, and metallic silver. I set hard constraints: no "patriotic cheese," no React, no emojis.

I handed that brief to Claude and asked for three files: index.html, styles.css, and script.js. It worked on the first try. Not because the AI is magic, but because I did the engineering work upfront.

The prompt started like this:

Act as an expert frontend developer. Build a single-page portfolio for "Tony" inspired by the gritty cinematic freeze-frames of Guy Ritchie films and the cel-shaded energy of Borderlands.

The rest was just guardrails. Mobile behavior, font stacks, and forbidden tech. It was several pages long before I hit "send."

The Takeaway

The AI is a beast at execution, but it's mediocre at direction. If you don't know what "good" looks like, you're going to get confidently average garbage forever.

The 45 minutes I spent writing that prompt were more valuable than the 40 hours I didn't spend learning a framework I'll never use again. The code is just the byproduct of a clear decision. Now, if I want to change something, I just open the file and tinker. No build logs, no dependencies — just the web, the way it used to be.

A new laptop is dangerous.

Not because it is fragile. Not because macOS is hard. Because a clean machine gives you the illusion that you should install everything.

Every terminal toy. Every productivity app. Every "must-have" tool from a blog post written by someone who thinks switching fonts counts as engineering.

I did not want that.

I wanted Neo — my new MacBook — to become a portable infrastructure workbench. Not a junk drawer with a keyboard. Something I could use for SSH, network troubleshooting, scripting, documentation, Git work, packet poking, lab notes, and the occasional "why is this thing listening on that port?" moment.

So I treated the setup like I treat infrastructure: install what earns its place, document the decisions, make it repeatable, and leave myself a way back.

The First Pass: Tools With Jobs

The first wave was the obvious stuff.

brew install btop nmap fastfetch
brew install bat ffmpeg jq ncdu wget
brew install --cask discord iterm2 rectangle google-chrome upscayl

That gave me the basics:

• btop for seeing what the machine is doing.
• nmap for network discovery.
• fastfetch because every new machine deserves a little vanity screenshot.
• bat, jq, ncdu, and wget because the default command-line toolbox can always be sharper.
• iTerm2, Rectangle, Chrome, Discord, and Upscayl for the actual daily-use side of the machine.

Nothing exotic. Nothing precious. Just useful pieces.

I did briefly install cask like it was still an old Homebrew workflow, which was wrong, mildly embarrassing, and exactly why setup logs matter. Modern Homebrew already handles casks. That line got removed from the final Brewfile.

The Shell: Make the Terminal Less Dumb

Once the machine had the basics, the real work started: making the terminal feel like home.

brew install \
  gh git-delta lazygit \
  ripgrep fd fzf eza zoxide starship \
  yq tlrc dust duf \
  tmux watch ssh-copy-id mtr iperf3 socat rclone \
  direnv uv pipx

This was not about making the prompt pretty. It was about reducing friction.

ripgrep replaces the old "grep through everything and wait" routine. fd makes file search sane. fzf makes history and file selection feel like cheating. eza gives me an ls that actually tells me something. zoxide turns folder hopping into muscle memory instead of archaeology.

Then starship gives the prompt enough context to be useful without turning the terminal into a spaceship dashboard.

The Git side got cleaned up too:

git config --global core.pager delta
git config --global interactive.diffFilter "delta --color-only"
git config --global delta.navigate true
git config --global merge.conflictstyle zdiff3

That one change — better diffs — is the kind of thing that does not look exciting in a screenshot but saves real time every day.

The Infra Kit: Because This Is Still My Laptop

Neo is not just for writing Markdown and looking organized. It needs to work when I am staring at a network problem.

So the toolset includes the things I actually reach for:

• mtr for trace-plus-ping path testing.
• iperf3 for bandwidth testing.
• socat for ugly socket tricks and quick forwarding.
• ssh-copy-id for pushing keys without manually mangling authorized_keys.
• nmap for discovery.
• rclone for moving data around without caring where it lives.
• speedtest for quick WAN sanity checks.

This is the difference between a generic "developer setup" and an infrastructure setup. I do not just need a code editor. I need a bag of small sharp tools for the moments when DNS is lying, a firewall is half-right, or a server is reachable only from the one place it should not be.

The Brewfile: No More Mystery Meat Installs

The most important file from this whole exercise was not a shell script. It was the Brewfile.

brew bundle dump --file="~/Documents/Brewfile/Brewfile" --force
brew bundle check --file="~/Documents/Brewfile/Brewfile"

That turns the laptop setup into something declarative.

Not "I think I installed some stuff."

Not "let me scroll through my shell history and reconstruct my decisions like a crime scene."

A Brewfile says: here is what belongs on this machine.

That matters because laptops are cattle until they become pets. The Brewfile keeps Neo from turning into an undocumented pet.

The Folder Structure: A Small Runbook for My Own Brain

I also created a clean working area under my MacBook documents folder:

mkdir -p Lab/{scripts,configs,notes,diagrams,logs,tools} Projects Screenshots

That gives everything a place:

Documents
├── Brewfile
├── Claude
├── Codex
├── Lab
│   ├── configs
│   ├── diagrams
│   ├── logs
│   ├── notes
│   ├── scripts
│   └── tools
├── Projects
├── Safari Bookmarks
└── Screenshots

This is boring on purpose.

Scripts go in Lab/scripts. Config backups go in Lab/configs. Notes go in Lab/notes. Diagrams go in Lab/diagrams. Screenshots stop landing randomly on the Desktop like digital laundry.

Then I pointed macOS screenshots there:

defaults write com.apple.screencapture location "~/Documents/Screenshots"
killall SystemUIServer

Tiny change. Big quality-of-life improvement.

SSH: Make the Laptop Useful Before You Need It

A new infra laptop needs SSH ready before the first emergency.

mkdir -p ~/.ssh
chmod 700 ~/.ssh
nano ~/.ssh/config
ssh-keygen -t ed25519 -C "monty-neo"
ssh-add --apple-use-keychain ~/.ssh/id_ed25519

This is not glamorous work, but it is the difference between calmly connecting to a box and fumbling with keys while something is already broken.

I also enabled Touch ID for sudo, because typing a password fifty times a day is not a security strategy. It is just cardio for your fingers.

The First Script: netcheck.sh

The first real script in the new Lab/scripts folder was a network sanity check.

The idea is simple: when something feels wrong, collect the first layer of facts quickly.

• What IPs does the machine have?
• What is the default gateway?
• What DNS servers are configured?
• Can I ping the target?
• What does the path look like?

That became netcheck.sh.

./netcheck.sh google.com

Not because it is revolutionary. Because it is repeatable.

Good troubleshooting starts with boring facts collected the same way every time.

The Checkup Script: Trust, But Verify

After the installs and tweaks, I added a second script: neo-checkup.sh.

That script checks the state of the machine:

• macOS version
• Homebrew status
• Brewfile health
• Active shell
• Git config
• SSH key permissions
• Screenshot path
• Local IPs
• Listening ports

That last part matters. A clean laptop should be quiet. If something is listening, I want to know what it is and why.

The checkup found a couple of normal Apple services and, more importantly, confirmed that the Brewfile dependencies were satisfied.

That is the point where a setup stops being vibes and starts being a known-good baseline.

The PATH Problem: One of Those Boring Things That Actually Matters

Homebrew also complained that /usr/bin was ahead of /opt/homebrew/bin in my PATH.

That sounds minor until you realize it means macOS might run the system version of a tool instead of the one you intentionally installed with Homebrew.

So the shell path got fixed:

export PATH="/opt/homebrew/bin:$PATH"
export PATH="/opt/homebrew/sbin:$PATH"

Then verified:

echo $PATH | tr ':' '\n' | head -10
which -a jq python3 pip3 openssl

I wanted Homebrew first. Not sometimes. Not depending on which terminal tab I opened. First.

That is infrastructure thinking applied to a laptop: deterministic behavior beats "it works on my machine" every time.

The Cleanup: Kill the Weird Stuff Early

A few things got corrected before they became permanent:

• Removed the unnecessary brew "cask" line from the Brewfile.
• Replaced deprecated speedtest-cli with Ookla's newer speedtest install path.
• Ran brew update, brew upgrade, brew cleanup, and brew doctor.
• Re-dumped the Brewfile after changes.
• Verified the Brewfile again.

The final check was simple:

brew bundle check --file="~/Documents/Brewfile/Brewfile"

The answer I wanted:

The Brewfile's dependencies are satisfied.

That is the laptop equivalent of green lights on a rack.

The Takeaway

This was not about making a MacBook look cool.

It was about turning a new machine into a known, repeatable, useful workstation.

The apps matter less than the method:

• Install tools with a purpose.
• Keep the setup documented.
• Put the machine state in a Brewfile.
• Create folders that match how you actually work.
• Fix the boring path and permission issues early.
• Write small scripts for repeatable checks.
• Verify the result.

Neo is not finished because no workstation is ever finished. But it is baseline-ready.

It can SSH into gear, test the network, work with Git, edit configs, benchmark commands, manage notes, capture screenshots in the right place, and rebuild its software loadout from a file.

That is the whole trick.

A good laptop setup is not a pile of apps.

It is a runbook you can carry.