Remember when AI was supposed to write your code while you slept? When the dream was a fully autonomous loop — you describe the feature, the agent builds it, tests it, ships it, and you wake up to a deployed product?
Yeah, that’s not what happened.
What happened is you’re now spending your afternoons carefully managing API costs, trimming context windows, and manually intervening every time your “autonomous” agent decides to hallucinate a dependency that doesn’t exist. You didn’t get a junior developer who works for free. You got a toddler with a credit card.
The promise of autonomous AI agents didn’t get solved. It got buried under a megabyte of context window and called progress.
Here’s what actually changed in agentic coding over the last year. The clever architectural workarounds — the chained prompts, the multi-agent orchestration, the elaborate state machines — they didn’t evolve into something better. They got flattened. Today, you can dump roughly a megabyte of UTF-8 text into a system prompt before things start to degrade, and that sheer volume of context replaced the need for elegant engineering.
That’s not a breakthrough in reasoning. That’s a brute-force solution dressed up as innovation.
Think about what that means in practice. You’re not building intelligent systems anymore. You’re curating context. Your job as a developer has shifted from creator to context manager — someone who decides what information goes into the prompt, how much it costs per invocation, and whether the output is worth the token spend. Every call to the API has to be intentional. Every context window has to be carefully managed. You feel less like an engineer and more like a babysitter watching a very expensive child.
We traded the dream of autonomous intelligence for the reality of manual curation, and nobody wants to admit it because the alternative — that AI still can’t reason — is too uncomfortable to say out loud.
The comments on Dan Luu’s notes from the field capture this perfectly. One observer called it the beginnings of “AI psychosis” — that creeping dread you feel when you realize the system you’ve been trusting to write production code is fragile, expensive, and fundamentally dependent on your constant oversight. Another pointed out the obvious: with API-only models, you’re not going to run anything in a loop. You’d sooner set dollar bills on fire. Every invocation costs money. Every context expansion costs money. Every hallucination costs money.
This is the part the AI hype machine doesn’t talk about. The demos look incredible — watch this agent build a full-stack app in three minutes! What they don’t show you is the forty minutes of prompt engineering, context trimming, and manual corrections that happened before the camera started rolling. They don’t show you the API bill. They don’t show you the developer staring at the output, trying to figure out if the code actually works or if it just looks like it works.
The gap between what AI demos promise and what AI development actually feels like has never been wider, and that gap is filled with token costs and quiet panic.
So where does this leave us? Not where the evangelists predicted, that’s for sure. The “crazy ideas” about autonomous coding loops didn’t get solved through better reasoning or smarter architectures. They got swallowed by massive context windows that mask the absence of genuine understanding. The model doesn’t know your codebase. It just has a very large window into it, and that window is expensive to keep open.
If you’re building with AI right now, here’s the honest truth nobody’s telling you: the current paradigm doesn’t reward autonomy. It rewards intentionality. The developers who win aren’t the ones who set up the most elaborate autonomous loops. They’re the ones who manage context ruthlessly, intervene strategically, and treat every API call like it costs real money — because it does.
The future of AI coding isn’t set-it-and-forget-it. It’s set-it-and-watch-it-like-a-hawk, and the sooner we stop pretending otherwise, the sooner we can build something that actually works.
The dream of autonomous agents isn’t dead. But it’s on life support, and you’re the one paying the hospital bill.
FAQ
Q: But aren't massive context windows actually a good thing?
A: They're useful, but they're a brute-force substitute for reasoning. Dumping a megabyte of text into a prompt isn't intelligence — it's pattern matching at scale. The model still doesn't understand your codebase; it just has more text to pattern-match against. Useful? Yes. A breakthrough in reasoning? No.
Q: So should I stop building with agentic AI?
A: No — but stop building autonomous loops and start building intentional interactions. Treat every API call as a cost center, manage context aggressively, and design for human-in-the-loop oversight. The developers who win right now are the ones who are intentional, not the ones who are hands-off.
Q: Isn't this just a temporary limitation that the next model will fix?
A: Maybe. But that's what everyone said last year, and the year before. Meanwhile, real money is being spent on fragile autonomous systems today. Build for the reality you have, not the promise someone is selling you for next quarter.