A principal engineer friend of mine asked me last week if everything he learned about building software was a lie. His brother, who isn't technical, built a working app with Claude Code, and he didn't need my friend's help to do it.
I wrote a short version of this on LinkedIn. I've kept thinking about it since, so I wanted to write more of it out here.
What happened
The app manages jobs and members for his brother's union. My friend was advising him and planned to set up patterns for the AI to follow first. His brother didn't wait. He kept brain dumping features into Claude Code until the app was done.
My first answer was the one I think a lot of us would give. Who knows if it'll scale, there are probably bugs hiding in there, wait until something breaks.
The more I thought about it, the less sure I was of that answer. It's a guess. Maybe something breaks, maybe nothing does. His brother knows the union rules and knows what the people using the app need. For a small project like this, maybe you don't need a big team. Maybe you need the person who knows the rules and has enough motivation to build it.
Who best practices were for
A lot of what we call best practice exists because people had to read and change each other's code. When I go through the usual list, most of it comes back to that.
Naming conventions and style guides exist so the next person can follow what you wrote without asking you. Don't repeat yourself exists partly because if the same logic lives in three places, the person changing it will probably find two and miss the third. Docs and comments exist because nobody can hold a whole codebase in their head, so we leave notes for each other. Code review exists so a second person understands a change before it ships, and so knowledge doesn't sit with one person who might leave.
All of that made sense to me as a Sr. TPM at Amazon. When lots of people touch the same code over years, you need shared habits or everything slows down.
AI changes part of that. It can read the whole codebase before it makes a change. If it looks, it can find the third copy of the logic. It can read a function and everything that calls it, so it leans less on a comment explaining what the function does. If the code is a little inconsistent, it can usually still work through it.
I'm not saying none of this matters anymore. Some of it might matter more, since clear structure probably helps the AI too. But the argument I hear most often is "the AI will get something wrong later, and then you'll need an engineer." I'm not sure that holds up. If the thing that gets it wrong can also read everything and fix it, the reason behind a lot of these practices shifts. I don't know yet which ones survive and which ones were mostly about people working together.
Where I still see engineers mattering
There are places where I've watched AI struggle, or where I still want someone experienced paying attention.
Infrastructure is one. Where the app runs, how it's secured, what it costs, what happens when a lot of people use it at once. A small union app might never run into those problems, but plenty of projects do, and those decisions are hard to undo later.
Deployments are another. Getting code from someone's laptop to something real people depend on, safely and the same way every time, still takes judgment. How you roll back, how you change the database without losing anything, how you find out something broke before your users tell you.
Polishing the customer experience is a third. AI can build a feature that works. Making it feel right for the people using it every day takes someone who is watching those people and cares about the small stuff.
The one I run into most is making sure features use the stack you already have. I've watched AI build OTP login from scratch when Twilio already does it. That means code to generate the codes, send them, check them and expire them, all of which Twilio Verify already handles. It works, but now there's custom code to maintain that didn't need to exist. Someone has to know what's already available and say "use that." The AI didn't ask, and the person prompting it might not have known to tell it.
What that might mean for engineers
I think a lot of engineers are going to end up in roles like forward deployed engineer, TPM or management. Closer to the people with the problem, helping them get what they need built and making sure it holds up once it's running. I'm still figuring out what that looks like myself.
The internet comparison
It reminds me of when the internet took off. People worried about what happens when your connection goes down and you can't do anything. That's still true. When the internet goes out, a lot of work just stops, mine included.
We built everything on it anyway. The dependence was real and so were the benefits. Over time we found ways to live with the risk, like backups, redundancy, offline modes, and people whose whole job is keeping things up. Most of that came after we were already depending on it, and I don't think anyone could have planned it all up front.
Depending on AI might be the same. If the AI is down or gets something wrong, someone like my friend's brother could be stuck. That's a fair concern. It was also a fair concern with the internet, and what happened is people kept using it and built ways around the failures as they found them.
It could just be different now. Nobody knows all the implications yet, me included, but I don't think it's the end of the world.
I'm curious if other engineers are seeing this too, or if you think I'm wrong.
