The Safety Was On

Every week, someone tells me AI is overhyped, doesn’t work, isn’t ready, isn’t real. Some of them are senior engineers. Some are executives. Some are people whose work would be transformed if they spent ten serious hours learning the tool. All of them are wrong, and all of them are wrong in exactly the same way.

I’ve watched this pattern long enough to be tired of it. The dismisser tries AI casually. Generic prompt, generic output, walks away convinced the technology is hype. Then they spend the next two years watching practitioners around them ship twice the work while insisting nothing is really happening. The technology gets better every quarter. The dismisser’s position gets worse every quarter. Neither side seems to update.

I want to tell you a story about a gun range.

The Safety Was On

A first-time shooter walks into a range. Loaded weapon in hand. They aim downrange, squeeze the trigger, and nothing happens. They squeeze again. Still nothing. They hand the gun to the range master with a look that says “this is broken.”

The range master takes the weapon, clicks off the safety, hands it back. The shooter squeezes the trigger and the gun fires.

The gun was never broken. The shooter didn’t know about the safety. The mechanism worked exactly as designed. The user lacked one specific piece of knowledge they didn’t know they lacked. In the absence of that knowledge, the most natural conclusion was “the gun doesn’t work.”

Every dismissal of AI I’ve heard in 2026 is a version of this story.

Every Dismissal Is a Safety-On Story

“I asked AI to write me a report and it gave me garbage.”

The safety was on. You used a generic prompt with no context, no examples, no constraints, no review step. You got a generic output. That’s the tool working as designed for the input you gave it.

“AI hallucinates. It makes things up. You can’t trust it.”

The safety was on. You weren’t running verification. You weren’t checking sources. You weren’t using a second model to adversarially audit the first. You handed off accountability to a system that doesn’t carry accountability, then blamed the system when it didn’t carry it.

“I tried it on something complex and it failed.”

The safety was on. Complex tasks require decomposition into pieces an agent can handle, specifications precise enough that an agent can execute them, and verification loops that catch failures before they ship. You skipped all three steps and gave the tool a monolithic ask. That’s how operator failure gets misread as tool failure.

In every case, the failure being described is real. The output was bad. The hallucination did happen. The complex task did fail. The dismisser is reporting their actual experience accurately. The misattribution turns the experience into a dismissal. The operator’s failure gets read as the tool’s failure, and the wrong lesson sticks.

What Using It Right Actually Looks Like

The dismissers will say “fine, show me what using it right looks like.” Fair. Here’s one technique out of dozens.

I ask my agent to write code for a feature. Standard task. The agent does it well. About 80% right. The remaining 20% is where failures live. Edge cases the agent missed. Assumptions it made that don’t hold. Security holes it didn’t price in. Tests that pass without verifying what they claim to verify.

Then I ask the agent to fire up a second agent to perform an adversarial review of the work the first one just did. The brief is hostile. Find what’s broken. Find what’s missing. Find the lazy assumptions. Find the things that will fail in production.

The two instructions are opposing. The first agent wants to please me by completing the task. The second agent wants to please me by tearing the task apart. AI is a pleaser by default, and the pleaser tendency is what produces overconfident first drafts that look right on the surface and break in production. When you ask the same model to please you in two opposing ways, the two outputs counterbalance each other. The pleaser energy that produced the overconfident draft becomes the engine of rigorous second-pass review.

That’s a five-minute workflow. It transforms the reliability of agent output. I wrote about this technique in depth in The Adversarial Audit. The core idea is that the same pleaser tendency that produces overconfident output can be inverted into rigorous review by giving the model an opposing brief.

The dismissers don’t know this technique exists. They don’t know any of them. They tried a generic chat once, got generic output, decided the tool was broken. They’re holding a power tool by the blade and wondering why it isn’t cutting properly.

Why AI Specifically

People don’t dismiss spreadsheets this way. They don’t dismiss IDEs, version control, calculators, search engines. Something about AI in particular triggers the dismissal reflex more than any tool I’ve watched in forty years of computing. A few reasons matter.

The interface is natural language, which creates an illusion of effortlessness. Users assume “I asked a question, the AI should know,” because that’s how human conversation works. They don’t apply the patience they’d give to learning a new programming language or a new framework. With AI, the expectation is competence on first contact.

The failures are confident. A hammer that doesn’t work is obviously broken. A search engine that returns nothing is obviously empty. AI that hallucinates produces output that looks like working output. It’s confidently wrong in a way other tools cannot be, which breeds suspicion of the whole category instead of suspicion of the specific use.

Marketing oversold it. Users were promised magic and got a power tool. When they discovered the power tool required skill, they felt betrayed by the promise instead of curious about the tool. The marketing hangover is real.

The skill curve is invisible. From the outside, the people who are good at AI look lucky or look like they have a magic prompt. They don’t. They have skill built over hundreds of hours of deliberate practice. From the dismisser’s vantage point, there’s no visible difference between “this tool requires expertise” and “this tool is hype.” Both look like the same thing if you haven’t put in the hours.

Ego is a factor. Senior practitioners have invested decades building skill in their current craft. The suggestion that a tool can amplify them feels, to some, like a suggestion that their craft was less than they thought. The craft is exactly what makes the tool useful. Without the underlying skill, the tool produces noise. With it, the tool produces output that compounds.

The Pattern Is Older Than AI

Every senior practitioner who dismisses AI in 2026 is making the same bet that senior practitioners made against the internet in 1995, version control in 2005, IDEs over plain editors, autocomplete, Stack Overflow, Copilot, and Docker. They were wrong every time. The pattern is so consistent it’s almost embarrassing.

In 1995, the senior engineers who refused to take the web seriously got passed by junior engineers who did. The seniors had decades of skill. The juniors had a willingness to learn the new layer. The juniors won. The rules of the game changed and the seniors refused to acknowledge it.

In 2005, the senior developers who dismissed version control as overhead got passed by teams that adopted it. The dismissers were right that there was overhead. They were wrong that the overhead was unjustified. Within five years, refusing to use git was a career-limiting position.

The same dynamic played out for IDEs, autocomplete, Stack Overflow, and every other layer of tooling that arrived between then and now. The dismissers in each wave were always the same kind of person. Skilled in the previous era. Confident that skill was enough. Refusing to invest in the new layer because the new layer felt unworthy.

AI is the current iteration. The dismissers in 2026 are making the same bet, with the same logic, and they will be wrong in the same way.

Receipts

I haven’t written production code in months. In the last six months I’ve shipped a cryptographic delegation framework for multi-agent AI, an autonomous agent platform on AWS, a voice system on Twilio, an AI-first IDE for orchestrating coding agents, a desktop tool with Azure DevOps integration, a dictation app on the Microsoft Store, and a REST API for agent state management. Approaching 8 billion tokens consumed in that window. Forty-one years of coding behind that output.

I’m one practitioner. The skill is learnable. The technique is teachable. The compounding effect is real and measurable. There are thousands of practitioners producing similar results across the industry right now. The pattern is established and the data is in.

I wrote earlier about being fired for using too much AI and then hired to lead with it. That arc happens because the dismissers eventually realize they were the ones with the safety on. By then, the practitioners who started earlier are years ahead.

The Gap Is Compounding Right Now

Two practitioners on the same team can already be a year apart in output. One of them learned to operate agents. The other dismissed the tool. The first now ships features in days that the second takes weeks to finish. The gap was a percentage when AI was new. It’s a multiple now. In two years it will be uncrossable.

If you’re a manager, you can already see this on your team. If you’re a senior dev, you can already see this in your peers. If you’re an executive, you can already see this in your divisions. Some of your people learned. Others didn’t. The output numbers don’t lie.

The dismissers believe they’re holding the line on quality, sanity, or professionalism. The line they’re actually holding sits in a previous era, and that era has already moved past them.

The Safety Is Still On

When the dismissers eventually come around, and most of them will, they’ll do what the previous-wave dismissers did. They’ll quietly start using the tool. They’ll claim they were never really dismissing it. They’ll spin their reluctance as “professional caution.” They’ll be a year or two behind the practitioners who started earlier, and they’ll spend the rest of the decade closing that gap.

The honest version of the conversation is this. The tool works fine. The skill is what’s missing. The gun is fine. The safety is still on. The range master is here. Clicking the safety off is a five-minute job. The shooting is a five-year journey.

Either you start the journey or you don’t. The tool doesn’t care. The dismissers around you don’t care. Your colleagues who already started don’t care either, because they’re focused on their own output and yours has stopped mattering to them in any way.

The choice has always been yours. Stop pretending the gun is broken.

First published May 15, 2026 on 42 Insights.