I recently started a new job as an Applied AI Engineer. Going in, I thought I knew quite a lot about AI. I use it constantly. I've built things with it, abused coding agents, experimented with local models, inference APIs, automation, weird workflows, all the usual nerd nonsense.
Turns out I was just in the wrong bubble. Not wrong, exactly. Just more conservative bubble than I realized.
I already treated AI as something extremely capable. I was never in the "fancy autocomplete" camp (or was very briefly), and I was already wrapping increasingly complex systems around my own work: context, tools, memory, workflows, verification, automation. Let the machine handle more of the mechanical thinking while I keep steering the thing.
I still think that direction was right. What I got wrong was the scale.
"Is This Worth Spending Money On?"
My personal AI usage has always had an invisible constraint attached to it: is this worth spending money on?
That question changes your architecture more than you think. You ask the smaller model first. You keep the context window under control and skip the retries you can't justify. You don't casually spawn five agents to attack the same problem from different directions, and you don't let one loop for an hour because maybe attempt seven will crack it. You optimize.
Which is completely sensible when it's your own credit card.
But there's another mode of operating. One where the constraint isn't "can I make this efficient enough to justify running it?" but simply "make this work." Now you can give the system more context, more tools, more autonomy, more attempts, more parallelism, more tokens, and above all more room to figure things out. And apparently that changes the answer to some questions from "yeah, AI probably isn't reliable enough for this" to "oh... We were just underpowering the whole thing."
There's a sneakier effect too. When every large context window, every retry, every agent loop and every parallel attempt costs you personally, you design around scarcity. Do that for long enough and scarcity starts to look like a property of the technology itself. You conclude "AI can't reliably do this," when the honest version is "AI can't reliably do this with one carefully rationed attempt, limited context and a budget-conscious architecture."
That's a very different statement.
My caution wasn't wrong. It was locally rational: tuned for personal projects, personal money and setups where waste actually mattered. What I hadn't internalized is how much capability appears when you stop trying to squeeze intelligence through the smallest possible pipe.
And this has started messing with my sense of what is realistically buildable.
Mundane Engineering-Insane
At work, some of the goals I heard in my first weeks sounded slightly insane. Not "invent AGI" insane. The mundane engineering kind of insane, where you hear the requirement and immediately think: that's an entire team, six integrations, months of implementation, a mountain of glue code, three internal tools and an unfortunate amount of human process.
Then you look at the same problem through an AI-native lens. Not "where could we add a chatbot?" Not even "which individual tasks can AI accelerate?" The actual question: how much of this entire process still needs to exist in its current form?
That's where things get weird.
Suppose the job is basically: read a large amount of company knowledge. Search several systems. Figure out what's relevant. Correlate information that was never written with this exact question in mind. Produce a result, a few dashboards, check it against policies and previous work, and escalate the few decisions that genuinely need a person.
Traditionally that isn't one piece of software. That's a workflow strung across multiple humans. Departments, even. And increasingly, the interesting unit of automation isn't one task inside that workflow.
It can be the workflow itself.
That was the scale jump for me.
The Factories Are Real
Then you look further out and discover people building actual software factories around fleets of agents. Not as a thought experiment. Not "one day, when the models are smarter." Today. Agents opening tasks, implementing things, reviewing each other's work, running tests, investigating failures, maintaining state, escalating decisions, and producing enough useful output that the bottleneck starts moving away from writing the code and toward designing the system that produces it.
That still sounds slightly ridiculous when I type it. But it works. Not perfectly, not magically, but well enough that you can no longer dismiss the direction as some distant sci-fi endpoint.
And once you've seen that, your horizon moves. Quite far.
Your Judgment, Multiplied
The part that matters most to me: none of this invalidates the way I was already thinking about AI. It reinforces it.
I've increasingly believed that the most powerful way to use AI is to build systems around your brain rather than in place of it. Your judgment stays in the middle. Your taste, your goals, your understanding of the problem, your ability to notice that something feels wrong and change direction. Around that you assemble increasingly capable machinery: research agents, coding agents, reviewers, search, memory, automation, specialized workflows. Whatever actually amplifies the way you work.
Because I don't think there will be one universally optimal "AI workflow." Someone can publish the most sophisticated agent setup imaginable, you can copy it perfectly, and still hate it. The useful system is partly a reflection of the person operating it.
AI multiplies what is already there. Your judgment gets multiplied. Your curiosity gets multiplied. Your ability to decompose problems gets multiplied. So do your bad assumptions. Which makes the whole thing much more personal than "learn these five prompts and become 10x."
The models will keep getting better without your permission. The part that's on you is learning to construct an increasingly capable layer of machinery around yourself without giving away the seat that decides where you're going.
That's why this new scale is so interesting to me. I've spent a long time thinking about individual agents and workflows. Now I'm starting to see systems of agents. Organizations of agents. Software factories, persistent roles, automated feedback loops, AI systems improving and guarding the processes of other AI systems. Things I would have filed under "interesting idea, probably too ambitious to bother building" keep moving into a much more dangerous category:
"...wait, we could actually do that."
Stranger Places
I'm increasingly convinced that one of the biggest mistakes we make with AI is evaluating it inside old workflows. We keep asking how AI could make an existing process 20% faster. Maybe the more interesting question is: if cheap-ish machine reasoning were simply another resource available to us, would we design the process like this at all?
That question leads to much stranger places.
I'm still cautious. Models still fail. Agents still do stupid things. Reliability, sources, verification, security: all of it still matters. More compute and more tokens do not magically turn a bad idea into a good system. But caution was never the thing limiting my imagination. I was cautious at roughly the right level. I was ambitious at entirely the wrong one.
The strangest part is that I don't think we've settled on the right abstractions yet. Chatbots, copilots, agents, skills, automations: these all feel like intermediate forms. We're still discovering what software looks like when reasoning itself becomes something you can provision, orchestrate and surround yourself with. Nobody has found the edges yet.
The ceiling is higher than I thought. Odd sentence to type for someone who assumed he was already one of the people "overusing AI. But it's the energizing kind of wrong, the kind where your general direction was right and the map extends a few hundred kilometers past where you thought the coastline ended.
So this is the scale.
Okay. Here we go then.
There's more to conquer.
P.S. as I had just finished writing this - Fable 5.1 just got released. Oh boy...
