A fellow developer leaned over to me the other day during a break, visibly frustrated, and said: “AI has definitely become more stupid. A year ago we could just ask for something simple and it built it right away. Now? We have to tell it every single detail, write massive prompts, and practically hold its hand to get anything working.”
His view isn’t uncommon. You see it on Reddit, in tech Discords, and across developer forums every week. People feel that large language models peaked early on and are now degrading in quality.
The Golden Era of “Vibe Coding”, has Ended.
When modern generative AI first took off, it felt like magic to almost everyone. Anyone could suddenly spin up a prototype app, generate digital artwork, write long articles, or piece together functional scripts with almost zero technical setup. People called it “vibe coding.” You threw a general idea into a chat box, sat back, and watched an entire project come out on the other side.
Now, that phase seems completely over. Today’s models often refuse to guess your intent, stumble when given vague goals, and demand explicit architectural constraints, schema details, and technical rules.
Did the Models Actually Get Dumber?
The short answer is no.
When LLMs first became widely available, the tasks people threw at them were remarkably basic compared to what we expect today. Developers were asking for simple, greenfield scripts-a standalone Node.js server, a clean React counter, or a generic script to parse a CSV file.
These are solved, median programming problems. The web has millions of identical examples of them, so the AI could provide a working snippet on its first attempt. Our baseline expectations were also far lower back then. If a machine spit out 50 lines of JavaScript that simply compiled without throwing an immediate error, it felt revolutionary.
The Production Reality Check: Outgrowing Greenfield Toys
Today, nobody is asking AI to just print a basic loop anymore.
Instead, developers are asking it to integrate complex state management into an existing monorepo, adhere to bespoke internal APIs, manage strict type safety across nested components, and account for production edge cases.
When you ask a model to do something complex using a vague, one-line instruction, it fails. Not because its reasoning degraded, but because complex software cannot be built on assumptions.
The Clinical Diagnosis: Why Wild Guesses Don’t Scale
In medicine, you see the exact same principle at work. If an untrained person walks into a clinic and says, “My stomach hurts, fix it,” a careless practitioner might give them an antacid and hope for the best. Sometimes that wild guess works, and the patient feels amazed. But a real clinician knows that abdominal pain could mean appendicitis, a peptic ulcer, or a dozen other critical conditions. You cannot treat a patient safely without blood panels, targeted palpation, and exact diagnostic criteria.
Software engineering is no different. The early “vibe coding” era was the equivalent of taking wild guesses that happened to land on simple targets. But once you move into real production systems, loose assumptions lead directly to architectural collapse.
Model Alignment and Context Bloat: The Real Culprits
What changed is that modern models are heavily aligned to follow instructions rather than make reckless assumptions. When a prompt lacks precise technical boundaries, the model defaults to cautious, generic boilerplate. It feels less creative or “dumber” simply because it is no longer taking the wild, hallucinated leaps that beginners used to mistake for intelligence.
On top of that, developers now frequently stuff hundreds of files into enormous context windows, expecting the model to figure out what matters on its own. Just like overloading a diagnosis with irrelevant lab data, stuffing unnecessary tokens into a prompt dilutes the attention mechanism and causes the output to degrade.
What Modern Engineering Demands from Us
So, what is actually required from developers in this phase?
We have to move past casual prompting and treat AI like an execution engine that requires strict specifications:
Define data models, schemas, and interface boundaries before asking for implementation code.
Stop dumping full repositories into context windows; isolate only the files relevant to the specific problem.
Write unit tests first so the output can be verified deterministically against actual criteria.
Deepen your own understanding of system design. If you cannot spot poor memory handling or bad state mutations yourself, no prompt will save the code.
The Novelty Is Over, the Discipline Begins
Generative AI didn’t suddenly lose its ability to write code. Our problems simply grew up, and our tooling became strict. The novelty phase has passed, and building reliable software still requires real engineering discipline.
