Real Engineers Dig With Their Bare Hands - Minid.net -->July 14, 2026<br>Real Engineers Dig With Their Bare Hands

Yes, Father, I have sinned. I let a machine write the boring parts. No, I am not vibe coding. There is a difference, and the difference is two weeks of rules, a clear architecture, automated checks, and knowing exactly when to take the shovel back.

Two neighbors stop in front of a construction site and look through the fence. Inside, five workers are using two enormous machines to finish digging a massive hole. One neighbor shakes his head. “Fifty people could have dug that with shovels. Everyone would have had a job.” The other looks at him and says, “Why stop at fifty? A thousand people could have dug it with their bare hands.”

My previous essay about working with AI generated a longer discussion than I expected on HN, and some people complained that I did not give any specific details about how I work. So, in this essay, I want to explain what I have actually automated in my engineering workflow. This includes access to a Git repository with all the rules I typically use in a large project.

Before getting into the practical part, though, I need to address the predictable objections:

You are vibe coding.

You are AI-pilled.

You will eventually forget how software works.

These objections argue against a point I am not making.

I am not saying that learning how things work under the hood is a waste of time. Quite the opposite. That knowledge is precisely what allows me to automate safely, inspect the result, and recognize when an agent has done something stupid. Delegating grunt work is not the same as delegating judgment. Running formatters, checking architectural boundaries, finding empty files, detecting unused dependencies, and preparing a migration plan are mostly mechanical tasks. Determining whether the generated code is correct, whether the abstraction makes sense, whether the architecture is appropriate, and whether the system should exist in the first place still requires an engineer.

The machine does not assume responsibility. I do.

When I was younger, I uploaded files manually through FTP and SSH. I edited code in text editors with no syntax highlighting, no autocomplete, no inline warnings, and no useful feedback until compilation failed. Sometimes the feedback arrived even later, when the system broke in production. Great times. Very character-building. To reduce human error (or at least give it fewer opportunities to express itself), I remember using Teleport Pro and WinHTTrack to crawl our applications and find broken links. Then text editors acquired syntax highlighting, which felt almost unfair. IDEs started warning us before compilation. Autocomplete became normal. Suddenly, the computer was helping instead of silently watching us make mistakes.

I replaced repeated uploads with rsync, wrote shell scripts, and eventually adopted version control, automated tests, CI/CD pipelines, infrastructure as code, dependency bots, static analysis, and increasingly sophisticated deployment systems. Each new tool eliminated another task that developers had previously considered a sacred manual ritual. None of those tools made knowledge about servers, networking, permissions, failures, or rollbacks unnecessary. They simply removed repetitive execution, caught mistakes earlier, and reduced the number of Friday evenings spent discovering that someone had uploaded the wrong folder to production.

AI agents feel like the next step in the same progression.

I am not outsourcing understanding. I am automating execution and catching errors closer to where they are introduced and writing boilerplate code. In any case, engineers still need to decide whether the code is correct, the abstraction makes sense, the architecture fits, and the system should exist at all. Heck, even Linus Torvalds reaffirms that Linux is not anti-AI. We have used graphical Git clients, IDE refactoring tools, and autocomplete for years without declaring that engineering is dead because someone clicked a button. But as my grandfather said to me multiple times, “convenience always wins over nostalgia”, especially when it also prevents mistakes.

Working with an agent is not fundamentally different from using another high-level interface over a complicated system. It is a new kind of GUI, although sometimes it is closer to a NOGUI because the interaction happens through language rather than menus. The interface is more powerful, but the principle is familiar. You describe the intended result. The tool performs a collection of lower-level operations, write boilerplate code for you. You inspect what it did. You approve, reject, or correct the result. The important difference is that agents can operate across a much larger surface area. They can read a repository, follow instructions, modify several components, run tests, inspect failures, and iterate. That does not make them infallible. It makes good instructions and...