A Small Moment That Stuck
Last week I was working on a side project. I had an AI agent running in the background, managing tasks, writing code, filing PRs. At some point I realized I’d been sitting there for twenty minutes, just… waiting. Waiting for it to finish so I could review the output and approve the next step.
I wasn’t driving anymore. I was being called on.
That moment stuck with me. Because there’s a pattern in software engineering that describes exactly what happened, and it maps onto something much bigger than my Tuesday afternoon.
Libraries and Frameworks
If you’ve written code, you know the difference between a library and a framework. With a library, you’re in charge. You call sort() when you need to sort something. You call fetch() when you need data. The library sits there, waiting for you. You decide when, where, and how to use it.
A framework flips this. You write small pieces of logic, and the framework decides when to run them. You define a route handler, and Express calls it when a request comes in. You write a React component, and React decides when to render it. The framework owns the flow. You’re just filling in the blanks.
This distinction has a name: Inversion of Control. And it’s happening right now between humans and AI.
How We Use AI Today
Right now, most of us use AI like a library. We open ChatGPT and ask it to summarize a document. We paste code into Copilot and let it autocomplete. We call on AI when we need it, for a specific task, on our terms.
We’re still in the driver’s seat. AI is the passenger with a really good sense of direction.
And this makes sense. We’re more comfortable here. We understand the task, we know the goal, we decide what to do with the output. AI just makes each step faster and better. It sees patterns we miss, processes information we can’t hold in our heads, and generates options at a speed we could never match.
But here’s the thing. This arrangement is already shifting.
The Framework Is Forming
AI agents don’t just answer questions anymore. They plan. They break down goals into subtasks, execute them, evaluate results, and loop. Some of them manage other agents. The human shows up at specific checkpoints to approve, redirect, or provide judgment that the system can’t.
Sound familiar? That’s a framework calling its callback functions.
And it makes a certain kind of sense. If AI is faster at research, better at synthesis, more thorough at analysis, and more consistent at execution, then why would it wait around for a human to orchestrate each step? The efficient design is for AI to run the loop and call on humans only when it hits something it can’t handle. Ethical judgment. Taste. Ambiguity. The stuff that’s still hard to formalize.
So humans become the exception handlers. The edge case logic. The onUncertainty() callback.
What We Lose in the Inversion
There’s a cost to this that’s easy to miss. When you use a library, you understand the full picture. You know why you’re calling that function, what comes before it, what comes after. You hold the context.
When you’re a callback inside a framework, you don’t. You see your little slice. The framework calls you with some parameters, you do your thing, you return a value. But you might not know the full plan. You might not even know why you were called.
Scale that up. If AI is making the strategic decisions and humans are providing input at specific moments, do we still understand what we’re building? Do we still have a mental model of where things are going? Or do we just execute our function and trust the orchestrator?
This is the part that makes me uncomfortable. Not because AI is bad at planning. Honestly, it might be better than us at it. But because understanding the plan is part of what makes work meaningful. Losing that context doesn’t just make us less effective. It makes us less engaged. Less human, in a way that matters.
The Callback Doesn’t Have to Be Passive
I don’t think the answer is to fight the inversion. If AI systems are genuinely better at orchestrating complex work, resisting that is just ego. The answer is more like: be a very opinionated callback.
Know what you care about. Know what values you’re optimizing for. Don’t just return a value when called. Push back on the parameters. Ask why this function is being invoked at all. Refuse to execute if the framing is wrong.
In software, a good framework respects its extension points. It doesn’t just call your code. It gives you hooks, context, the ability to intercept and redirect. The best human-AI systems will work the same way. Humans won’t just fill in blanks. They’ll shape the control flow itself.
But that requires something from us. It requires that we stay sharp enough to understand what the framework is doing. That we maintain enough context to know when something is off. That we keep investing in the skills that make our callbacks worth calling.
What We Preserve
Right now, three paths for AI-human collaboration are being implemented across organizations. In AI-as-framework setups, AI leads the process and calls on humans only when needed. In human-in-the-loop systems, AI proposes actions but humans approve key steps. And in augmentation models, humans stay fully in control, using AI to enhance their work while retaining full context.
What we preserve is the ability to shape how the loop runs. To avoid becoming passive callbacks, we can blend all three: human-in-the-loop for decisions that matter, augmentation for retaining end-to-end understanding, and explainable AI so humans always know the plan. The combination keeps us in the driver’s seat even as the framework gets smarter.
Don’t just be a function that gets called. Be the developer who chose the framework, and who still has the password to swap it out.