LLMs are exactly as good as what you feed them.
Experienced engineers feel like the gap between them and everyone else just got smaller. Someone with six months of prompting can ship something that looks like what took years to learn how to build. That’s the wrong read.
The output looks the same if you don’t look closely. The architecture doesn’t. The failure modes don’t. When traffic spikes and that generated code hits a path nobody thought about, the years show up.
GIGO didn’t go anywhere, it just moved up a level. Used to be garbage data in, garbage results out. Now it’s garbage context in, garbage code out. The model will happily build you a payment flow with no idempotency, a webhook handler with no retry logic, an auth system that stores sessions in memory. Confidently, with clean variable names and proper error handling on the surface. Looks great in a demo.
I’ve been reading through some large codebases recently, tracing authorization paths, looking at how different subsystems handle the same security boundary. The tooling is genuinely good at helping me move through code faster. But the reason it works is I know what to look for. I know when a gate function was written before the feature it’s supposed to gate. The model helps me trace it, but the part where you go “wait, this doesn’t cover that” – that’s not promptable. That’s years of things breaking in production, pager or not.
Newer engineers are where I don’t have a clean answer. The ones I’ve worked with who got good fastest owned incidents, traced things through layers, felt the pain of their own shortcuts. Not sure how you build that muscle when the shortcut produces working code on the first try.
The people most worried about their skills being devalued are usually the ones who’ve built the most. The people most excited are split between folks who genuinely see what’s possible and folks who’ve never had to debug a connection pool under load. That’ll sort itself out. Might take a few production outages, but it’ll sort itself out.
Years of building things aren’t less valuable because the typing got faster. If anything they matter more now, because the bottleneck isn’t writing the code anymore. It’s knowing what to write, and what not to.