AI Timeline

Anthropic pulled Claude Fable 5 and Mythos 5 worldwide after a US government directive, only three days after launch. The important part was not only that a frontier model disappeared. It was the mechanism: a remote model endpoint became a policy lever, and every customer using it inherited someone else's jurisdictional decision.

For my own AI tooling, this made the boring portability work feel less optional: provider-agnostic harnesses, open-weight fallback paths, and local copies of the context that actually make a model useful. The question stopped being "which model is best today?" and became "what still works if that endpoint is gone tomorrow?"

Running multiple agents with different models, skills, and tools in parallel. Codex 5.3, Opus 4.6. That same month, Karpathy renamed the whole thing "agentic engineering". The name and my daily practice converged at the same time, which is probably not a coincidence.

On the one-year anniversary of "vibe coding", Karpathy retired his own term in favour of "agentic engineering". His reasoning: agentic because the new default is that you are not writing the code directly most of the time. You orchestrate agents who do, and act as oversight. Engineering because there is real craft to it, something you can learn and get better at.

The third of his three coinages, and the one that matches my daily practice closest.

The curve bent. Models got dramatically better at coding and at managing themselves. Plan mode showed up everywhere. The rigorous spec-kit discipline stopped being a prerequisite, because the agents started handling that themselves.

Agent skills arrived alongside: installable knowledge packs that give an agent domain expertise on demand. The inflection wasn't a new model, it was self-management.

Multi-model agents arrived in earnest. I started using CLI-based agents instead of only editor extensions, mixing models with different temperaments (Gemini 3, Opus 4.5, GPT-5.2 and Codex) depending on the kind of task in front of me.

September brought Codex Cloud Tasks. A lot of the output was bad. But I managed to build a complete, non-trivial application entirely through cloud tasks, managed from my phone.

That changed what I thought was possible more than any single demo had. Shipping a real app with no editor open and no code in front of me was the point where "assistant" stopped being the right word for these tools.

I went the other direction: detailed specs and task breakdowns, treating the agent like a junior-junior programmer with no memory and no architecture sense. Spec-Kit and similar approaches.

It helped. It was also exhausting. The discipline that made it work was almost as much effort as writing the code yourself.

Claude Code shipped and the timeline lit up with agentic demos and bold claims. That spring, VS Code Copilot got agent mode too.

I ran experiments and found the agents hard to control: hours spent keeping them on track, undoing bugs they introduced, fighting them on coding style. "Vibe coding" was the right name for it. It felt like vibes, not engineering.

Karpathy coined "vibe coding": building software by describing what you want and, in his framing, letting yourself forget that the code even exists. The second of his three coinages from this era; the name landed at exactly the moment the tools made it feel right.

Through 2024 I kept ChatGPT around as a discussion partner while my actual work stayed in VS Code with Copilot. Then Canvas arrived, and I could generate small games and prototypes and run them right there. Fun, but hemmed in: the editor would break, and you were stuck in a single file.

In November 2024 Anthropic published the Model Context Protocol and the noise around agent tooling started to build. It planted a question: if I can build this much in a chat window, what could I do with a real setup?

The real change for me was small and cheap: subscribing to GitHub Copilot for $10 a month. Ghost text, inline chat, a chat panel: AI inside the editor instead of in a separate tab.

For PowerShell it was basically perfect. That was the moment it stopped feeling like a toy.

GPT-4 changed the baseline. PowerShell scripts mostly worked on the first try. Qlik load scripts became semi-useful. Extension development got noticeably easier, though still not good.

The defining shift was confidence: it was now worth trying the model on a task before reaching for the manual.

Andrej Karpathy wrote that the hottest new programming language is English. It read like a joke at the time. Three years on, it reads like a forecast, and the first of three coinages from him that bracket this whole era.

I did what everyone did: pasted problems into the chat box. The results were entertaining. I got some simple Qlik Sense extensions working, but only with a lot of patience and a lot of manual pasting of documentation.

The Qlik load scripts it wrote were hilariously wrong: invented function names, made-up parameters. Good material for office jokes about how AI would never take our jobs. PowerShell scripts worked, sometimes, kind of.