A short history of the tricks we invented to make AI usable, and why most of them didn't last.
If you've been building with AI since 2023, you know this feeling. You learn a trick, you get good at it, you tell your friends about it, and eighteen months later, nobody uses it anymore.
"Let's think step by step." Prompt templates. Chain-of-thought tricks. Fighting with the model to get valid JSON. Half the agent framework your team spent months learning.
People call this a hype cycle. It isn't. There's a real pattern behind it, and once you see the pattern, it gets a lot easier to tell which of today's AI techniques are likely to still be around in a few years, and which ones are probably temporary.
Here's the pattern: AI tends to destroy the tools built to cover for its own weaknesses. If something exists only because the model can't do a task, that thing is on borrowed time. When a newer model learns to do the task, the trick doesn't get better. It just disappears.
Bellow you find a brief timeline of what hapened so far.
2023: The Magic Words Era
ChatGPT launched in November 2022 and reached a hundred million users faster than any consumer product before it. Almost immediately, an informal set of rules grew up around how to talk to it.
People found that adding "let's think step by step" made math answers better. They found that saying "you are an expert with 20 years of experience" made answers sound more confident. In late 2023, Google DeepMind published a paper showing that the phrase "take a deep breath and work on this problem step by step" outscored many other hand-written prompts. It was a funny result, but people treated it like serious advice.
Prompt marketplaces popped up. "Prompt engineer" became a job title with a surprisingly high salary. Courses, newsletters, and giant PDF lists of prompts followed.
None of this was fake. The tricks worked, because the models at the time had a real gap: GPT-3.5 would skip steps in its reasoning unless you told it not to.
Then reasoning models arrived. The step-by-step thinking moved inside the model itself, where it belonged. Today, telling a top AI model to "think step by step" does almost nothing, because the model already does that on its own. The magic-phrase era ended not because people got smarter at prompting, but because the tricks got built into the model and stopped being tricks.
The magic phrases faded out. What survived was something much simpler: clear, plain instructions, which were never really a trick to begin with.
2023 to 2024: The Scaffolding Era
The next wave was about structure. If the model couldn't be trusted, people built a cage around it.
This is when LangChain became the go-to answer for "how do I build an app with AI", and RAG (having the AI look things up before answering) became a standard pattern. It's also when a lot of energy went into one very annoying problem: getting the model to reliably output valid JSON.
The problem was real. LangChain's own early docs describe it plainly: its first agents had the model generate JSON to represent a tool call, then parsed that JSON to figure out which tool to run, because there was no cleaner way yet. Developers papered over the gaps with exact formatting instructions, examples, and the occasional bribe or threat aimed at the model, all to stop a stray comma from breaking a parser at 2am.
Then OpenAI shipped function calling in June 2023, letting the model request a tool call directly. JSON mode followed, making valid JSON more likely but still not guaranteeing a schema match. In August 2024, Structured Outputs arrived, constraining the model's response to a developer-supplied schema. It doesn't guarantee the values inside are correct, but it made schema-breaking output a largely solved problem.
A large class of these workarounds became far less necessary almost overnight.
Agent frameworks followed a messier version of the same path. Some of what LangChain did in 2023, including that early JSON-parsing approach, was working around limits in what models could reliably do. As models got better at tool use, teams increasingly had the option of skipping the framework for simpler apps and calling the model API directly. That doesn't mean frameworks became pointless. LangChain itself argues complex applications still benefit from the orchestration and observability a framework provides. But the problem those early workarounds existed for, models being unreliable at picking and calling tools, did get smaller.
The workarounds mostly disappeared. What stuck around was the underlying need: people still want structured output, they just don't have to hand-build it anymore.
Late 2024 to 2025: The Plumbing Era
By this point, the hard problems weren't really about what the model said. They were about what the model could reach.
A model can reason beautifully and still be useless if it can't see your calendar, your database, or your support tickets. Every company building an AI product was writing the same custom connection code, over and over, in slightly different ways.
Anthropic released the Model Context Protocol, known as MCP, on November 25, 2024, to fix this. It gives AI models one standard way to connect to outside tools and data, instead of a custom wire-up for every single tool. OpenAI, Google, Microsoft, and other major companies all added support for it within about a year, which is fast for this kind of industry-wide standard.
And here's where the story gets more interesting.
2025 to 2026: The Model Learned to Skip Tool Menus, But MCP Didn't Die
By late 2025, a real downside of MCP had become obvious. Every single tool a model can use has to be described to it in advance: its name, its inputs, what it does. Connect a handful of tool servers to a real production system, and you can burn through 150,000 words of setup text before the model even sees the user's question. Worse, when tools are chained together, every result in between, even a giant file, has to pass back through the model. Companies ended up paying a top AI model to act as a copy machine.
The fix, described by Anthropic in November 2025 and separately worked out by Cloudflare and others, was surprisingly simple: stop making the model choose from a list, and let it write a small program instead.
Models are very good at writing code. So instead of listing every tool by name, developers started giving the model a small set of code building blocks and letting it write a short script that wires them together. The in-between data flows through the code, not through the model's memory. A loop that used to take six back-and-forth steps becomes one line of code.
The results were dramatic. The company Pydantic replaced more than 40 separate tools with just 3, and cut the amount of text needed by 90 percent. Cloudflare shrank thousands of separate tool endpoints down to two. The well-known developer Simon Willison said he'd stopped using MCP with his coding tools entirely, preferring plain command-line tools instead.
This is what people mean when they say "AI can just build its own tools now." And in a real sense, it can. Give a modern AI agent a terminal, some login details, and a goal, and it will build what it needs, test it, and keep it around for next time. Developers no longer have to anticipate every capability in advance.
So did MCP die?
No. And this is the part of the story that actually matters most.
MCP's download numbers went from roughly 2 million a month at launch, to 97 million a month by March 2026, to nearly half a billion a month by the time the next major update shipped in July 2026. That update removed the parts of MCP that required the model and server to keep a live back-and-forth session open, so servers can now run on ordinary, everyday web infrastructure. It also tightened up security to match standard login systems, and added a formal process for retiring old features safely.
Read that list again: simpler hosting, better security, a retirement process for old parts. That isn't a list of features for "picking a tool from a menu." That's the kind of update made to something that has become basic infrastructure.
The part of MCP that was covering for the model's weakness, a plain list of things the AI is allowed to do, faded out on schedule, just like everything else in this story. But the part of MCP that solves problems no smarter model can fix on its own grew roughly 250-fold.
Summary
Here's the rule the whole story points to:
Workarounds die. Agreements survive.
A workaround exists only because the model can't do something yet: magic phrases, JSON coaxing, most agent frameworks. Each has an expiration date set by the next model release, and most didn't last more than eighteen months.
An agreement is a deal about identity, permission, and trust: who's allowed to do this, on whose account, revocable by whom. A smarter model doesn't grant itself access to a company's systems or create an audit log on its own. That's a people problem in a technical disguise, which is why no model release fixes it. "AI can just build its own tools now" is true, but it still can't decide, on its own, that it's allowed to run them.
So the question worth asking about any AI technique is simple: is it covering for a weakness, or is it an agreement? The first is temporary. The second tends to survive every model release, even when the underlying problem sticks around and just gets solved a different way each time.
The tricks were always meant to be temporary scaffolding. The risk is mixing up the scaffolding for the building.
Top comments (0)