Word Homies
The term “vibe coding” has become so muddy that it’s almost useless, mostly because it collapses two completely different workflows into one bucket:
- Blind chat-box hammering: Copying and pasting errors into a chat box over and over until the red text goes away. It eventually “works,” but the author has zero idea what side effects, unhandled edge cases, or permission leaks were baked into the the code
- Harness-driven systems development: Working inside an IDE harness where the model acts as a high-speed drafting partner against your actual repo, but you are driving the architecture, inspecting the diffs, and auditing the blast radius.
There’s a lot of tribal pushback right now from folks whose entire identity is wrapped around what Ai is quickly replacing (replaced?). But for anyone who actually manages infrastructure, syntax has always been the cheap part—system architecture, state management, and blast radius are what actually matter. (Look at that Em—Dash…)
Echoing what @computer-janitor said about dependency surfaces: I’d trust a compact, AI-assisted script written against the standard library that I have personally traced and audited over a “battle-tested” GitHub dashboard dragging in 400 unvetted npm packages just to render three buttons and an API call. Traditional open-source isn’t automatically secure just because a human typed it. Stuff like supply chain poisoning and abandoned dependencies are very real attack vectors on any network.
The divide between safe AI-assisted code and absolute network liabilities comes down to operator discipline.
The greatest utility of an LLM isn’t that it writes the boilerplate—it’s that it exposes you to patterns, libraries, or system calls you might not have pulled off the top of your head. But that only works if you have the self-control to hit the brakes the second it outputs something unfamiliar. If the model introduces an unfamiliar flag, socket call, or data structure, I have to go research it to death before that code ever touches a compiler, let alone a service.
That’s where blind chat-prompting falls apart. If someone doesn’t understand the underlying stack or OS permissions, they won’t even realize the model just bound a debug server to 0.0.0.0 or bypassed TLS verification to “fix” a connection error. The code functions, but the attack surface is wide open.
To @f41n’s carpentry analogy: you don’t need to hold a degree in metallurgy to know how to frame a wall that won’t collapse under load. Most solid homelab sysadmins and self-hosters are polymaths—the classic “a jack of all trades is a master of none, but oftentimes better than a master of one.” You know enough about networking, container isolation, file systems, and authentication to recognize bad structural integrity when you see it.
I run my own AI-assisted tools on my servers and network daily without losing sleep. Not because I have blind faith in a probabilistic text generator, but because the trust isn’t in the model but rather the verification pipeline:
- Architectural boundaries: The tool gets scoped down to least privilege (read-only tokens, dedicated service users, segmented VLANs/subnets, no raw root/docker sockets unless strictly isolated).
- Tooling harness over chat: Building with an integrated IDE harness where linting, type-checking, and git diffs force you to see every single line changing across the project.
- Continuous scrutiny: If you don’t know why a block of code works, it doesn’t get deployed until you do.
I do this because I’m genuinely interested in the code and function there of and I learn more by taking the time to do it. (and I’m one of ‘THOSE’ sickos that like learning)
If you treat the model as a tireless junior developer that drafts what you architect, and you hold it to strict code review, you can get maintainable tools tailored exactly to your homelab. If you treat it like an oracle and just press “accept all,” you’re eventually going to have a very bad afternoon at some point. But then again, just have Ai fix it… right?