Right, so I’ve just spent my Friday night automating something that would have taken about forty-five minutes to do manually. Again. For probably the dozenth time in my life, if I’m being honest.

The thing is, I got this “new” MacBook Pro, and by new I mean it’s my old 2019 Intel work machine that I inherited when they upgraded me to an M3. Four years old, but free is free, and it beats paying for my own laptop. Problem is, when I turned it on after sitting in a drawer for the better part of a year, it immediately triggered about a million vulnerability alerts in our Raveneye system. Within hours, I got a very polite message from Phil on the cyber team asking what exactly I’d done to reach the top of their vulnerability leaderboard. Brilliant start.

But beyond the security theatre, I’m absolutely sick to death of setting up computers manually. Click here, install there, configure this, remember that password, find that license key, wonder why nothing’s working properly.

Back in the day, when I was messing about with desktop PCs, this stuff was actually quite fun. There was something satisfying about building a system from scratch, tweaking everything just so. But somewhere along the way (probably around the fifteenth time I had to reinstall everything after some update went sideways) the novelty wore off completely.

So instead of doing the sensible thing and just getting on with it like a normal person, I’ve decided to solve this once and for all. Because apparently I’d rather spend a Friday night writing shell scripts than click through another installer wizard, and honestly, I’m not even sorry about it.

This isn’t about being an automation obsessive or some sort of productivity guru. This is about being fundamentally lazy and wanting my computer to sort itself out so I can get on with actual work.

the rabbit hole of infinite possibilities

Here’s what actually happened: I opened my laptop, saw that beautiful clean desktop, and thought “Right, just need to install Chrome and VS Code, sorted.” Two hours later I’m deep in some GitHub repo reading about the philosophical differences between package managers, wondering if my choice of terminal emulator says something fundamental about who I am as a person.

It’s like that moment when you’re supposed to be getting ready for something important but you start reorganising your wardrobe instead. Before you know it, you’ve colour-coded everything, created a complex system for seasonal rotation, and completely missed whatever you were meant to be doing. Except instead of clothes, it’s command-line tools, and instead of getting ready, I’ve got actual work piling up.

The setup process has become this weird modern ritual where we convince ourselves that spending days configuring our environment is basically the same as being productive. “I can’t write any code until my terminal looks exactly right,” we tell ourselves, whilst installing our fifteenth different syntax highlighter.

Spoiler alert: the terminal was fine. The code wasn’t going to write itself, regardless of how aesthetically pleasing my colour scheme was.

when homebrew becomes your dealer

And then there’s Homebrew. Crikey, Homebrew. It’s like that mate who always knows where to get the good stuff, except the “good stuff” is command-line utilities and the satisfaction comes from that brief moment when everything installs without throwing a tantrum.

“Just one more package,” you tell yourself, installing some obscure tool that promises to revolutionise the way you manage your dotfiles. “This’ll definitely make me more productive.” Six dependency conflicts later, you’re googling error messages and wondering why you thought automation would be simpler than just clicking buttons.

Homebrew is simultaneously the best and worst thing that’s ever happened to macOS. It’s brilliant for getting exactly what you want, but it also has this delightful habit of installing seventeen different versions of Python that all hate each other and refuse to cooperate.

But when that brew install command actually works perfectly? Pure magic. Everything installs cleanly, your terminal stays happy, and for exactly thirty seconds you feel like you’ve got your entire digital life sorted. Then you try to install something else and discover that your carefully balanced ecosystem is more fragile than a house of cards in a wind tunnel.

the security panic spiral

Right, and don’t even get me started on the security paranoia. We’ve all become properly mental about this stuff. “Is this package safe?” “Who maintains this?” “What if it steals my cryptocurrency?” Like mate, you’re installing a text editor, not giving someone your bank details.

But here’s the thing… we should be paranoid, shouldn’t we? We’re literally running code written by random strangers on the internet. It’s like accepting drinks from someone you’ve just met, except the drink might also install a keylogger and send your browser history to some bloke in Belarus.

So we read security blogs, check GitHub star counts like they’re credit ratings, and spend ages vetting every single dependency. Then we happily download seventeen different Electron apps that are basically just websites wearing a trench coat pretending to be desktop software.

The cognitive dissonance is beautiful. “I’m not installing this command-line tool, it only has 500 GitHub stars and the last commit was three weeks ago. Anyway, time to update Discord for the fifteenth time this month.”

the productivity theatre

Here’s where it gets properly mental: I’ve just spent more time optimising my development environment than I’ll probably save in the next six months. It’s like spending your Friday night building the perfect study setup instead of actually studying.

“But look how fast I can list directory contents now!” I tell myself, admiring my newly installed eza command that displays files in slightly prettier colours. “This’ll definitely make me more productive!”

No it won’t, will it? I’m still the same disorganised mess I was yesterday, just with better syntax highlighting.

But there’s something addictive about the optimisation process. Every small improvement feels like progress, even when the actual work remains exactly as difficult as it was before. It’s like reorganising your desk instead of doing homework… technically you’re creating a better working environment, but really you’re just avoiding the thing you should be doing.

The truth is, perfect tools don’t make perfect work. But they do make us feel slightly more in control of the chaos, and sometimes that’s enough to actually get started.

why we actually do this mad stuff

Look, here’s the real reason we obsess over our setups: it’s not about the tools, it’s about control. In a world where everything’s constantly breaking, updating, or changing without warning, having one small corner of digital perfection feels like a tiny victory against the chaos.

Your development environment becomes this sacred space where everything works exactly how you want it to. Every keystroke is mapped to your preferences, every colour is chosen specifically for your eyes, every tool does exactly what you need it to do. It’s like having one room in your house that’s absolutely perfect, even if the rest of the place is falling apart.

Plus (and this is crucial) it’s procrastination that actually looks productive. Your boss walks past and sees you deep in terminal configurations, and they think “Look at them, so dedicated to optimising their workflow!” They don’t know you’ve been avoiding actual work for the past three hours by researching the perfect git aliases.

It’s the same impulse that makes people spend hours organising their Spotify playlists or curating their Instagram feed. We want some corner of our existence to be exactly right, even if (especially if) everything else is a complete mess.

the fresh start delusion

And there’s something properly seductive about starting fresh, isn’t there? New computer, new you. This time you’re definitely going to be organised. This time you won’t end up with forty-seven different text editors because you couldn’t decide between them. This time your desktop won’t look like a digital bomb went off.

(Narrator: They absolutely would end up with forty-seven text editors.)

It’s like moving house and swearing you’ll keep everything tidy this time, whilst secretly knowing you’ll probably recreate the exact same chaos within a month. But for those first few days, when everything’s perfectly organised and working exactly as intended, you genuinely believe you’ve cracked the code of digital existence.

The fresh start mythology is powerful because it feeds into our deepest fantasy: that we can optimise our way out of being human. That if we just get the setup right, we’ll become the sort of person who never procrastinates, always writes perfect code, and definitely doesn’t spend entire evenings falling down Wikipedia rabbit holes about obscure programming languages from the 1970s.

the scripts that changed everything (sort of)

So here’s what I actually built: a collection of shell scripts that can set up an entire development environment with a single command. It installs languages, configures tools, sets up the perfect terminal environment, and even handles security considerations. It’s beautiful, it’s comprehensive, and it definitely took longer to write than it would have taken to just click through installers like a normal person.

The macOS Setup Scripts include everything from essential CLI tools (git, ripgrep, eza, bat) to programming languages (Node.js, Python, Go, Rust), GUI applications (VS Code, Docker, Rectangle), and even the fun terminal eye candy (neofetch, cmatrix, pipes.sh). There’s a main setup script for the essentials and an optional tools script that asks before installing each tool. After all, even automation should have some boundaries.

But here’s the thing… and this is important… it actually works. And more than that, it makes the whole process kind of fun. Instead of clicking through endless setup wizards, you run a script, watch the terminal scroll past with all sorts of technical-looking output, and feel like you’re in some sort of hacker movie.

Plus, the next time I get a new computer (or when I inevitably mess this one up beyond repair), I’ll have everything ready to go. Whether the scripts will still work by then is another question entirely, but that’s Future Felix’s problem. Present Felix is quite proud of his Friday night’s work.

what you actually get from all this

If you’re thinking about automating your own setup process, here’s what you actually get:

The obvious stuff: Faster setup next time, consistent configuration, and the ability to recover quickly if everything goes wrong. Pretty standard.

The less obvious stuff: You learn loads about how your system actually works, you understand what all your tools are doing, and you develop strong opinions about package managers that you can bore people with at parties.

The secretly important stuff: You get that feeling of control I mentioned earlier. When your development environment is exactly how you want it, everything else feels more manageable. It’s like wearing clothes that fit properly. You don’t think about it, but you feel better.

The honestly embarrassing stuff: You become the sort of person who has strong opinions about dotfile management and gets unreasonably excited about new terminal emulators. Sorry in advance.

defending the beautiful madness

Look, I’m not going to pretend this was a sensible use of a Friday night. I could have set everything up manually in an hour and spent the rest of the evening doing literally anything else: touching grass, seeing actual humans, or finishing that one project I keep pretending doesn’t exist.

But here’s the thing: sometimes the “inefficient” path is actually the more interesting one. Yes, I spent a Friday night writing scripts to solve a problem that barely existed. But I also learned loads, built something genuinely useful, and had a proper laugh doing it.

In a world where everything’s optimised for efficiency and productivity, there’s something rebellious about taking the long way round just because it’s more fun. We’re constantly told to find the quickest, most streamlined way to do everything. Sometimes it’s worth ignoring that advice and embracing the beautiful, chaotic mess of doing things the hard way.

Plus, and I can’t stress this enough, the setup process is now genuinely entertaining. Instead of boring installer wizards, you get scrolling terminal output that makes you feel like you’re in Hackers. That’s got to be worth something, right?

the real talk section

If you’re still reading this and thinking about automating your own setup, here’s the honest truth: you probably shouldn’t. Not because it’s not worth doing, but because you’ll definitely get carried away and spend way more time on it than makes any rational sense.

But if you’re the sort of person who enjoys solving problems that don’t really exist, who gets unreasonably excited about elegant solutions to simple tasks, and who has ever spent an entire evening configuring something that was working fine already, then mate, this is absolutely for you.

Just don’t blame me when you find yourself at 3 AM researching the optimal way to manage your shell history. We’ve all been there, and we’re all silently judging ourselves for it.

The setup scripts are there if you want them. They’re secure, well-documented, and they’ll save you loads of time. Whether they’ll save you more time than they took to write is… well, that’s not really the point, is it?

Written by someone who definitely should have just installed everything manually and gone to the pub instead. No productivity was harmed in the making of this article, though my Friday night plans certainly took a beating.