Every hobby project starts with a lie: “I just need a small thing that does X.”
That is always how it begins. You have one annoying little problem, nothing serious, nothing that needs a full app, nothing that needs architecture. Just one tiny thing. X should do Y. That’s it.
And then somehow, three hours later, you are thinking about settings pages, edge cases, user roles, export formats, logging, backups, maybe a plugin system and some kind of admin panel. For what? No one knows. No one is using this thing. There is no userbase. There is no production incident waiting to happen. There is no angry support email from a guy called Mark who lost 300 hours of work because your little tool forgot to save one checkbox.
But your brain does not care. Your brain goes: “Okay, but what if we had 10k users and one of them uploads a broken file while the internet drops and the app crashes during the sync process?” And then you build for that person.
That person does not exist. But building for them is fun.
That is the annoying part about overengineering. People usually talk about it like it is just a failure of discipline. Like you are supposed to sit there, build the smallest possible version, ship it, and be a mature adult about it. And sure, that is probably correct. But also, where is the fun in that?
Half of the fun of a hobby project is the play pretend part. You take this tiny little idea and treat it like it matters. You pretend it is real infrastructure. You pretend there are users. You pretend there are edge cases worth solving. You start with a button, then add loading states, error handling, settings, a config system, and suddenly you are basically building enterprise software for a tool that renames four files in a folder.
And honestly, I kinda love that. It makes the project feel alive. It makes the thing feel like more than just a script you hacked together in one evening. It feels like a product. Like it could become something. Like maybe, if you just add this one more serious part, the thing becomes real.
Which is dumb. But also kinda true.
The problem is that this mindset does not stay in programming. It leaks into everything. I have this one friend where every time I show him some cool product, his response is basically: “Ah, I can 3D print that and build it myself for cheaper.” And technically, yeah. Maybe he can. But also, put it on the list of the other three million side projects.
Because that is the part people forget when they say “I can just build that myself.” You then have to actually build it. And once you build it, you own it. Every little flaw is now yours. Every shortcut is yours. Every weird decision is yours. Every part that is kinda fine but not really fine is now sitting in your head forever.
This happens to me with basically everything. Programming, tinkering, car stuff, bike maintenance. I would rather have some random dude in a garage change my oil than do it myself and then spend the next 300 kilometers thinking: “Did I do everything right?”
And yeah, I know. It is an oil change. It is not exactly advanced science. You drain oil, change the filter, put oil back in, check the level, done. Very impressive monkey task.
Still, if I do it myself, my brain will not shut up. Did I tighten the bolt enough? Did I overtighten it? Was that sound already there? Is the bike dying? Am I stupid? Did I just create a very expensive problem because I wanted to save 40 euros and feel competent for 20 minutes?
The funny part is, I do not even think the random garage dude is perfect. He can make mistakes too. Probably does. But I do not know his mistakes. And that changes everything.
When someone else does the work, you only see the result. When you do the work yourself, you see the whole process. You know every part where you were unsure. You know every shortcut. You know every “yeah this is fine for now.” You know which part is held together by vibes and one comment that says “fix later.”
From the outside, a thing can look finished. From the inside, you see all the cracks.
I think this is the actual problem. Once you do something yourself, you know the issues. And not in a useful way. In a “I can no longer look at this like a normal person” way.
Artists have this with their own drawings. They see every line that is wrong because they remember fighting with it. Developers have this with code. You look at a feature that works and instead of thinking “nice, it works,” you think “yeah but that one function is disgusting and I should rewrite it before anyone finds out.”
Normal people do this with their lives too. You compare your own messy internal version to someone else’s finished outside version and then act surprised that you feel bad. Which is kinda insane. But also very human.
The process is always uglier than the result. That is just how making things works.
Before you build stuff yourself, it is easy to imagine that good things are just good. Like competent people sit down, make a plan, build the thing properly, and then ship it. Then you actually build things and realize most finished things are probably more like: “Okay, this part was rewritten four times, this part is weird but works, this part should not be touched, and this part only exists because of one edge case from 2021 that nobody remembers.”
But you do not see that from the outside. You only see it in your own work. So your own work feels worse. Not because it is worse. But because it is yours.
You saw the sausage being made.
And this is where AI changed something for me. I am not totally sure if it is a healthy change, but it is a change nonetheless.
I still overengineer my hobby projects. Do not get me wrong. I am still the type of person who thinks a ripping pipeline needs a TUI. Of course it does. Why would it not.
But the feeling is different now. When I build with AI, I am not always as deep in every single line of code. I still decide what the thing should do. I still guide it. I still review stuff, fix stuff, rewrite stuff, and complain when it produces some absolute nonsense. But I do not carry every tiny implementation detail in my head in the same way.
There is a bit of distance. And that distance is weirdly freeing.
When I write everything myself, every bug feels personal. Every bad abstraction is mine. Every shortcut is mine. Every weird little hack is something I did and now have to emotionally live with.
With AI, it feels more like working with a very fast junior dev who is also somehow overconfident and drunk. You still need to watch it. You still need to know what you are doing. You still need to catch the nonsense before it becomes your problem. But not every ugly internal detail feels like a direct reflection of you.
And I know that sounds like cope. Maybe it is.
The problems are still there. Not knowing every part of the mess does not mean the mess disappeared. But emotionally, it matters. It makes building feel less like holding every screw in your own hand and more like directing the shape of the thing.
That can be dangerous, obviously. You can now build more stuff faster, which means you can also overengineer faster. You can create even more half-finished projects. Even more “almost real” apps. Even more little systems that probably did not need to exist.
AI does not fix the three million side projects problem. It gives it steroids.
But for me, in the small world of programming, it also removed some of the anxiety. Not all of it. Just enough that building feels a bit lighter again.
And maybe that is the point. Maybe overengineering is not always the enemy. Sometimes it is play. Sometimes it is how you learn. Sometimes it is how a tiny project starts feeling like a real thing. Sometimes it is just fun to pretend your app has users, scale, problems, and a future.
But sometimes it is also fear. Sometimes it is a way to avoid finishing. Sometimes it is a way to avoid trusting the thing. Sometimes your brain says “we need one more edge case” when what it actually means is “I do not want to release this yet because then it can be judged.”
And those two things look very similar from the outside.
Fun overengineering and anxiety overengineering both create settings pages no one asked for. Both create dashboards for imaginary users. Both make you build serious infrastructure for unserious projects.
The difference is how it feels.
One gives you energy. The other makes you check the oil bolt in your head for the next 300 kilometers.
So maybe the goal is not to stop overengineering. That sounds boring anyway.
Maybe the goal is just to notice when it stopped being play and became fear wearing a builder costume.
