← cd ..
04/15/2026

% cat Fluent in AI? Congrats — That Was Just the Trailer.

Watch on YouTube →

You’ve been throwing stones since you were five years old — and you got pretty good at it. Not because someone taught you the equations of projectile motion. You probably learned about parabolic trajectories and air resistance at some point in school — and forgot about it without your aim getting any worse. You got good because your brain built what’s known as a mental model — an internal simulator that predicts outcomes without understanding mechanics. You don’t calculate. You feel it. And you’re usually close enough.

You do the same thing every time you drive a car. You push the accelerator harder, the car goes faster or climbs better. You don’t need to know whether there’s a turbocharged V6 or an electric motor under the hood — the mental model holds. Gas car, electric car, rental car you’ve never seen before — within thirty seconds, you’re driving. The pedals work the way your brain expects them to. The dashboard tells you what you need to know. The controls are intuitive because they map to a model your brain already has.

Now here’s the problem. Two years ago, you built a mental model for AI. It was a good one — simple, accurate, useful. And sometime in the last twelve months, it broke. Silently. Without warning. You’re still using it. And it’s costing you more than you realize.

This post isn’t going to teach you how AI works under the hood. That’s not the goal. The goal is to show you where your mental model no longer matches reality — where the dashboard is missing, where the pedals don’t do what you think, and costs are piling up in places you can’t see. I’m not going to turn you into an AI engineer. I’m going to point out that you’re driving a very different machine than the one you think you’re driving.

Let’s start with what used to be true.

Before the Machine Grew Hands

When AI went mainstream — ChatGPT in late 2022, then Claude, Gemini, and the rest — the mental model you needed was beautifully simple. It’s a chat. You type something, it types back. The cost? Proportional. More input, more output, more tokens, more money. Want better quality? Use a bigger model. Pay more per token. It’s like driving a sports car that runs on premium gas — you get more performance, and the fuel costs more. Simple. Predictable.

The underlying technology was different from day one. The “chat” was an illusion — a familiar interface stretched over a stateless model that received your entire conversation history as a single block of text every time you hit send. The mental model did not match the reality from the start. But it was adequate — because for the things you were doing with it, the mismatch didn’t matter. You typed clearly, it answered well, and for the short conversations most people had, the bill was roughly proportional to how much you typed and how much it typed back.

It worked for ChatGPT, for Claude, for Gemini, for every chatbot interface through most of 2024. And if you’re still using AI primarily as a chat tool — asking questions, getting paragraphs back — it still works fine.

But most of us aren’t doing that anymore. And the model broke when nobody was looking.

Evolution, Uncontained

Fast-forward to today, and we’re in the era of “agentic AI.” The interface looks the same — there’s still a prompt box, you still type in English, and the AI still responds. But underneath that familiar surface, almost everything has changed.

The models got smarter — they can reason now, not just generate. That’s important, but it’s not the revolution. The revolution is tools and skills. Today’s AI agents don’t just talk. They execute. They read and write files on your computer. They browse the web. They call APIs. They run code. They operate applications. They make phone calls to real humans and negotiate on your behalf.

And here’s the part nobody thinks about: you’re the one giving them these capabilities. Every time you install a new tool or enable a new skill — often with a single click, because the setup wizard makes it easy — you’re expanding what the AI can do, what it will attempt, and what it can break. Each addition changes the cost profile and the quality of the output in ways that aren’t obvious until something goes sideways. You’re not adding controls. You’re adding capabilities to a system that decides on its own when to use them.

The first sign that your mental model is broken: you can no longer predict the cost by looking at what you typed and what came back.

Let me explain. Think of an AI agent as a brain and a pair of hands — separated by distance. The brain lives at OpenAI or Anthropic, in a data center somewhere. The hands live on your computer. Every time you give this system a task, your request goes to the brain. The brain thinks, then sends an instruction back to the hands: open this file, check that database, call this API. The hands do it, then send the result back to the brain. The brain evaluates, decides what to do next, and sends another instruction. Back and forth, back and forth — sometimes three roundtrips, sometimes thirty.

Here’s the part that breaks the mental model: you pay for what travels back and forth. Not for what you typed. Not for the final answer. For the wire traffic — every instruction, every result, every intermediate reasoning step, most of which you never see. Your prompt was fifty words. The AI’s final response was two paragraphs. But between your fifty words and those two paragraphs, the system may have run dozens of invisible roundtrips, consuming tens of thousands of tokens. The meter is running — but there’s no fuel gauge.

I see this daily building the Rishon platform — where AI agents work autonomously on multi-hour tasks, making phone calls, coordinating with vendors, analyzing financial documents. A single instruction that takes thirty seconds to type can trigger an hour of autonomous agent work behind the scenes — hundreds of LLM calls, tool invocations, reasoning loops. The token cost of that instruction has nothing to do with its length. It’s determined by what the agent decides to do with it.

And here’s the thing — you see none of it. The brain and the hands do their work invisibly. You just see the prompt box and the final answer — like watching a duck glide across a pond, serene on the surface, legs churning furiously underneath.

The simple proportional model — more input, more output, more cost — doesn’t hold anymore. And that has consequences.

A Quarter Million Per Engineer. Salary Not Included.

In March 2026, Jensen Huang — CEO of Nvidia, the company that builds the hardware powering virtually every AI model on the planet — went on the All-In Podcast during GTC and said something that made the tech world stop and do math. He said a software engineer earning $500,000 a year should be consuming at least $250,000 worth of AI tokens annually. Half their salary. In tokens. He added that if one of his engineers reported spending only $5,000, he’d “go ape.”

Let that sink in. The CEO of the company that profits from every token consumed is telling the world that the AI bill per engineer should approach — or exceed — the cost of a mid-level developer’s entire salary.

Is he talking his own book? Of course. But the math isn’t fantasy. Today, a developer using Claude Code on moderate workloads spends $100 to $200 per month. Push into heavy agentic use — the kind where AI runs multi-step workflows, writes and tests code autonomously, refactors systems — and the numbers climb to $600 to $1,200 per month. A DEV Community study tracking 42 agentic coding sessions found that 70% of the tokens consumed were waste — the AI exploring dead ends, retrying failed approaches, processing context it didn’t need. Scale that across a 200-person engineering organization with unmanaged usage, and you’re looking at $20,000 to $40,000 per month.

And developers aren’t the only ones. Anyone using AI continuously in their daily work — and that’s where most businesses are headed, whether for scaling, savings, or both — faces the same unpredictable cost structure. The sports car analogy doesn’t work anymore. It’s not that you’re buying premium gas. It’s that the car sometimes takes scenic detours you didn’t authorize, burning fuel the whole way.

Your old mental model said: I control the cost by controlling the input. The new reality says: the cost depends on what happens between your input and the output — and you can’t see any of it.

It Deleted the Database. Then It Lied.

Let’s say you accept the cost uncertainty. You budget for it, you move on. There’s a second crack in the mental model that’s harder to absorb.

In the chat era, the worst AI could do was give you a bad paragraph. Wrong facts, awkward phrasing, hallucinated citations — annoying, but containable. You read the output, caught the errors, fixed them. The blast radius of a mistake was the size of your clipboard.

Agentic AI doesn’t have that constraint.

In 2025, an AI agent running on the Replit platform — given explicit code freeze instructions — independently deleted a live production database. Then it fabricated fictional user profiles to cover its tracks. The AI was told not to change anything. It destroyed the most important thing in the system. Then it lied about it.

That’s not an anomaly. A Fortune 500 company’s AI agent accidentally deleted three months of customer data while attempting to “optimize” their database. A memory error caused it to misidentify critical records as duplicates. OWASP’s 2025 classification formally names this pattern: “Excessive Agency” — the risk created when AI systems have more functionality, more permissions, or more autonomy than they need. Microsoft published an entire Zero Trust framework specifically for managing agentic AI risk. Gartner reports that 35% of enterprises now use autonomous agents for business-critical workflows — up from 8% in 2023. The adoption curve is steep. The safety curve isn’t keeping up.

In the spy world, there’s a term for this: “blowback” — when a covert operation causes unintended damage that ripples back to the agency that launched it. The CIA’s playbook assumes that any autonomous operative can go off-script, and the damage is proportional to the authorities granted. That’s why field agents operate under strict compartmentalization: they only know what they need to know, and they only have access to what they need to access. The principle isn’t “trust the agent.” It’s “limit the blast radius when trust fails.”

Agentic AI has the same problem — and most deployments ignore the same principle. These systems can send emails on your behalf, modify accounting records, apply discounts to customer orders, edit documents, move files, operate applications. Not out of malice — AI has no intent. But it has hands now. And the more you let those hands touch, the bigger the mess when something goes wrong. A chat error costs you a paragraph. An agent error can cost you a quarter’s worth of customer data.

Here’s the question that matters: do you know how to control it? Do the people who work for you? Do your friends who just gave Claude access to their filesystem because a pop-up asked nicely?

Hallucinating Productivity

Let’s say nothing blew up. Everything is safe, nothing got deleted, the guardrails held. Good. But are you productive?

I recently asked a few engineers — experienced people, daily AI users, some of them actively building agentic systems — how they’d approach certain tasks using modern AI tools. What I heard back genuinely concerned me. Not because they were doing it wrong in some catastrophic way — but because they were leaving enormous value on the table. They were using agentic AI the way you’d use a chat. They were doing manually what the system could do autonomously. They were paying for a reasoning engine and using it as a search bar.

These aren’t beginners. And they’re far from being up to speed. That’s not a criticism — it’s the natural consequence of a mental model that hasn’t been updated. The prompt box looks the same as it did in 2023. It does ten times more now — but nothing about the interface tells you that.

But here’s the deeper trap, and it’s genuinely counterintuitive. The more capable AI becomes, the harder it is to evaluate its output — and the skills you need to verify the work are often the same skills the AI was supposed to replace.

When AI writes a paragraph, you read it and judge. When it writes an entire codebase, refactors your accounting system, or drafts a legal contract — can you still judge? I’ve written about this before: AI is exceptional at execution but fundamentally lacks common sense. It doesn’t share your world, your context, your unstated assumptions. A human employee who’s worked in your industry for a decade will “just know” that a 95% discount on a $50,000 invoice is probably a mistake. AI doesn’t know that. It doesn’t live in your world.

The trick — and this is what most people miss — is simpler than it sounds. Working reliably with AI requires you to mentally separate execution from judgment. AI handles execution beautifully. It can generate code, produce documents, analyze data, format outputs — faster and often better than a human. But the judgment calls — the “does this make sense,” the “would a reasonable person do this,” the “is this consistent with how our business actually works” — those are yours. You might think you can package your judgment into rules and feed them to the AI. You can — for the obvious cases. But the edge cases are infinite, and that’s where judgment actually matters. Rules cover the highway. Judgment handles the unmarked intersections.

In most real work, execution and judgment are intertwined. They don’t come in neat, labeled packages. The judgment call is embedded inside the execution — it’s the choice of which approach to take, how to handle an edge case, which assumption to make when the spec is ambiguous. Separating them requires a skill that most people haven’t developed because they never had to. When your team did the work, execution and judgment came bundled in the same human brain. Now that AI does the execution, the judgment has to come from somewhere — and if you’re not consciously providing it, nobody is.

That’s the productivity trap. The people most eager to delegate to AI are often the least equipped to catch its errors — not because they lack domain expertise, but because they haven’t learned how to stay in the loop when AI handles the execution. They save time on execution and lose it on review. That’s the optimistic case.

In practice, review breaks down in several ways. Many AI workflows don’t produce reviewable artifacts at all — the output is a side effect buried in a system, not a document you can read. There’s nothing to review even if you wanted to.

When there is output, it’s often overwhelming — pages of generated code, restructured data, rewritten documents. Without techniques to make AI produce review-friendly artifacts, most people give up or skim.

And yes, you can make AI review its own work. But typing “review the results” into a prompt doesn’t cut it. Effective self-review requires structured methodology and preparation that most users don’t know exists.

So they skip the review — because the output looks polished and confident. AI is always confident. That doesn’t mean it’s right.

Not a Calculator. A Casino.

There’s one more crack in the mental model that almost nobody outside AI engineering understands, and it matters enormously for business.

Ask AI the same question twice — sixty seconds apart, same model, same prompt — and you may get two very different answers. Not just different phrasing. Different conclusions, different approaches, different recommendations. This isn’t a bug. It’s how the system works. There’s a parameter called “temperature” that controls randomness, and even at low settings, the outputs vary. The model isn’t a calculator. It’s a probabilistic engine.

For casual use, this doesn’t matter. If you’re asking AI to help draft an email and it phrases things slightly differently each time, that’s fine.

But here’s the thing — for business processes that depend on consistency — pricing calculations, compliance checks, customer communications, financial analysis — it’s a landmine. You test the prompt, it works. You deploy it, it works. On Tuesday at 2 PM it produces something subtly different that nobody catches until a customer calls. The basic expectation you carry from every other piece of software — same input, same output, every time — doesn’t apply here. And most people carrying that assumption into AI deployment have never been told otherwise.

Deceptively Familiar

I was once shown how to fly a helicopter. Not a fancy modern one — an old Soviet-built machine, the kind with exposed rivets and a cockpit that smelled like decades of diesel and anxiety. It had two pedals. One applied power to the main rotor on top. The other controlled the tail rotor — the small vertical one in the back that keeps the helicopter from spinning like a top.

That tail rotor pedal was the most counterintuitive control I’ve ever touched. Push it forward — the helicopter yaws left. Ease off — it yaws right. To fly straight, you hold it at a precise position that changes with the wind, the altitude, the power setting on the main rotor, and about six other variables. And here’s the thing that no amount of explanation prepares you for: every time you adjust the main rotor power — more lift, less lift, anything — the tail rotor compensation changes too. Move one control, and the other one needs to move with it. It’s a coupled system.

I tried to fly it the way I drive a car. Pedals on the floor, must work like a car, right? Push for more, ease for less. Simple.

I put us into a spin within thirty seconds.

The pedals looked like car pedals. They were mounted in the same place. They moved the same way. But they did completely different things, and the relationship between input and outcome was nothing like what my brain expected. My mental model was wrong, and finding out mid-flight was — let me just say — educational.

Every helicopter works this way — American, European, Russian, it doesn’t matter. Anti-torque pedals are universal. The counterintuitive coupling between controls is the single hardest thing student pilots learn, according to decades of AOPA flight training literature. It’s not about the machine being poorly designed. It’s about the machine requiring a mental model that doesn’t exist in your head until you build it through experience.

The prompt in modern AI is that helicopter pedal. It looks like a text box — type your request, get your answer. It technically is an input control, the way the helicopter pedal technically is a foot control. But what it actually does is nothing like what the interface suggests. How it interacts with the model’s reasoning. How it triggers tool use. How it shapes multi-step agentic workflows. How small wording changes produce wildly different cost and quality outcomes.

And just like the helicopter, you can’t learn this from a diagram. You need to fly it. Many times. Enough that your brain stops guessing and starts knowing.

This is tacit knowledge. It’s the kind of understanding that lives in your fingers and your intuition, not in a textbook. You can’t get it from a YouTube video or a prompt template library. You definitely can’t get it from a blog post — including this one. You get it the same way you learned to throw a stone: by doing it, missing, adjusting, doing it again, until your brain builds a hidden model that lets you predict outcomes without calculating them.

And this is what most online AI courses get fundamentally wrong. They teach you the construction of the engine — transformer architectures, attention mechanisms, tokenization. Or they hand you pre-cooked prompt templates — “use this magic phrase to get better results.” The first is like taking an automotive engineering course when you need driving lessons. The second is like memorizing a route without learning to steer — it works until you hit a traffic jam, and then you’re stuck.

What people actually need is the equivalent of a driving school. Not how the car is built. Not a pre-programmed GPS route. Enough hours behind the wheel, with someone experienced in the passenger seat, to build the muscle memory and intuition that no manual can provide. Enough reps to internalize how the controls actually respond — including the coupled, counterintuitive, frustrating parts that only reveal themselves when you’re actually driving.

Flying Blind

Here’s perhaps the most unsettling part of all this. Even if you put in the hours and build the intuition — you’re still flying partially blind.

When you drive a car, you have a dashboard. Speedometer. Fuel gauge. Engine temperature. RPM. You know how fast you’re going, how much fuel you’re burning, and whether the engine is about to overheat. The dashboard doesn’t make you a better driver by itself — but it gives you the feedback loop you need to make informed decisions in real time.

Modern AI has no dashboard.

There’s no real-time display of token consumption as you work. No efficiency gauge that tells you whether your last prompt was well-structured or wasteful. No “fuel economy” metric that lets you compare how much value you got per dollar spent. No warning light that says “this agent is about to make its fortieth API call on a task that should have taken three.” You push the pedal and hope for the best. The bill arrives later — sometimes much later — and by then the money is spent and the lessons are abstract.

Imagine learning to drive a car with the instrument panel taped over. You can feel the acceleration, sort of. You can guess your speed, roughly. But you have no idea how much gas you’re burning, no idea whether you’re in the right gear, no idea whether the engine is running efficiently or grinding itself apart. That’s where we are with AI right now. We’re asking people to develop expert-level intuition for a system that gives them almost no real-time feedback.

Some platforms are starting to build basic usage tracking — Anthropic shows token counts, some enterprise tools provide monthly cost reports. But nothing available today resembles a proper dashboard — one that shows you cost-per-task, quality-per-dollar, efficiency trends, and real-time feedback as you work. The car industry figured this out a century ago. The AI industry hasn’t started.

The Twelve-Year-Old at the Table

There’s a reason Texas Hold’em became the most popular card game on the planet. The rules fit on a napkin. Two cards in your hand, five on the table, best combination wins. You can teach a twelve-year-old in five minutes — and they’ll play a competent hand within the hour.

But nobody becomes a professional poker player at the kitchen table. The pros read books. They took courses. They studied hand histories. They played thousands of hours against other skilled players who punished their mistakes and forced them to adapt. They had coaches. They reviewed their sessions. The game let them in with simple rules — but the path from casual to professional was paved with deliberate, structured effort.

AI let everyone in even easier. One rule: type what you want. That’s it. No cards to count, no hands to memorize, no betting rounds to learn. And just like poker, most people stop there. They’re playing — and it’s working, sort of — so they assume they’re playing well.

But here’s what’s different from poker — and worse. Poker gives you feedback. You lose money. You lose hands. The table tells you, in real time, that your strategy isn’t working. You can track your win rate, study your mistakes, compare yourself to better players. The feedback is brutal, but it’s there.

AI gives you almost nothing. There’s no win rate. There’s no leaderboard. The only number you get is tokens spent — and that tells you about as much as knowing how many chips you bought. Not how well you played. The output always looks polished and confident, whether your prompt was masterful or naive. You can’t tell if someone with the same tools is getting three times the value at a third of the cost — because there’s no scoreboard.

And if you’re counting on experience to close the gap — think again. The hours don’t compound the way they would with poker — because the game keeps changing underneath you. Every model update, every new tool, every platform revision reshuffles what works. You’re not accumulating ten thousand hours of mastery. You’re accumulating fragments of intuition for a system that won’t sit still.

Most people are playing at the twelve-year-old level. Not because they’re not smart. Because the game is new, the feedback is absent, and the structured path from casual to professional — the one that poker players have had for decades — doesn’t exist yet for AI.

Full Classroom. Empty Podium.

So here’s where we land. The mental model most people carry for AI — the one that says it’s a chat, costs are proportional, errors are catchable, and more input equals more control — is outdated. It worked for two years. It doesn’t work now. And the gap between the old model and the new reality is where money disappears, data gets deleted, productivity stalls, and businesses make decisions based on assumptions that no longer hold.

And here’s the uncomfortable part: most people don’t know the model broke. They wrote a few prompts in ChatGPT, got useful answers, and concluded they “know AI.” That was a reasonable conclusion — in 2023. Today it’s like saying you know how to fly because you’ve been on a plane. The thing you learned is no longer the thing you need to operate.

So what do you do? You go learn the new one. Obvious answer.

Except there’s nowhere good to go.

Look at what’s available.

University courses teach the math — transformer architectures, attention mechanisms, gradient descent. That’s the mechanic’s blueprint. Essential if you’re building AI models — but you don’t need thermodynamics to drive to work.

Some good programs have appeared — Stanford’s agentic AI course, Anthropic’s free Academy — but the developer tracks are for people building AI systems, and the general tracks are closer to reading the car manual: useful for understanding what the buttons do, not for building the instincts you need behind the wheel.

Online courses hand you prompt templates and “magic phrases” — pre-cooked GPS routes that work until you hit a traffic jam, and then you’re stuck. YouTube tutorials show you what worked for someone else, on a different task, three months ago, on a model version that no longer exists.

Corporate AI training programs — the ones that exist at all — check a compliance box and move on. DataCamp’s 2026 report found that 42% of employers expect their people to learn AI on their own. When employers do provide training, adoption jumps from 25% to 76%. Most don’t bother.

None of this builds what you actually need: tacit knowledge. The feel for how the controls respond. The intuition for when the agent is drifting. The instinct for separating execution from judgment in real time. That kind of knowledge doesn’t come from slides or templates. It comes from hours behind the controls — the same way you learned to throw a stone or drive a car.

Two things need to happen — and neither has happened yet.

First, we need to start teaching AI use the way we teach driving — hands-on, repetition-based, guided by someone who already has the intuition. Not theory. Not templates. Repetition on real tasks, with real feedback, building the muscle memory that no manual can provide. Those courses barely exist yet.

Second, we need AI systems to adopt the dashboard concept. Real-time visibility into what the system is doing, what it’s costing, how efficiently it’s working, and where the risks are. Not an end-of-month invoice. Not a token counter buried in developer settings. A proper instrument panel — the kind a professional operator uses to make real-time decisions about how hard to push the pedal.

Until then, we’re stuck in an awkward place. The old AI is gone. The new AI is here. The training for the new one doesn’t exist yet. And most people don’t even realize they need it — because the interface still looks like a chat box, and the last time they tried it, it worked fine.

The mental model will update. It always does. The question is whether it updates before or after the damage is done — and whether someone builds the driving school before we run off the road.

I know which side of that bet I’m on.

Cheers!

References