I was sitting on my porch the other night with a friend — a software engineering leader who works in regulated medical devices. He was telling me how excited his organization is about AI. Leadership sees massive productivity gains. Fewer people, faster output, lower costs. The pitch writes itself.

And I get it. I use AI every day. I build with it. I write with it. It's genuinely incredible.

But when I described how I actually use AI — what it's like in practice, day to day, as someone who's been building software for a long time — his face changed.

"Huh," he said. "That's... not how they're thinking about it."

No. It's probably not.

Here's the version I gave him. AI is amazing about 95% of the time. But 5% of the time, it didn't understand what you were really asking for — because human communication is still a thing and being articulate is essential — or it gave you something subtly wrong, or it gave you something really wrong. And in order to detect that 5%, you still need to know what you're doing. You absolutely need to pay attention.

If you've ever worked in software, you know this phenomenon: it takes just as much effort to handle the edge cases as it takes to build the happy path. The middle-of-the-strike-zone cases aren't the hard part. The weird stuff at the margins is. And most non-technical people don't understand that — they see the 95% and assume the job is basically done.

The 5% is where it gets expensive. And it's where expertise matters most.

The First 80%

Here's what AI is amazing at. You give it a well-described task, and it gets you 80% of the way there shockingly fast. Scaffolding, boilerplate, first drafts, prototypes, "give me something that does roughly this" — AI is unbelievably good at that. Sometimes better than good. Sometimes it blows your mind.

When I first started using AI for real work, I was blown away regularly. If you're starting a brand new, small, well-understood thing from scratch, AI can feel like magic. You describe what you want. It builds it. You're done in an afternoon instead of a week.

That's real. That's not hype.

I've built several products with AI coding assistance at this point. And there have been plenty of times where I vibe-coded a solution to something, felt great about the progress — and then hit an impenetrable brick wall. Something that just didn't work and couldn't be made to work the way AI had structured it. So I threw away most of it and rewrote nearly the whole thing by hand.

Now, you could argue the vibe-coded version was still useful — it was a proof of concept that helped me clarify my thinking. And that's fair. But I still had to throw it away and rewrite. The AI got me to the idea faster, but the actual working solution? That was mine.

And over time, I've come to recognize something important: AI is a partnership, not a delegation. If you think you're going to "fire and forget" — hand it a task, accept the result, check it off your list — you're probably not going to love what you get. Maybe not today. Maybe not this week. But eventually.

And that's where the hard part starts. It always was.

The Last Mile

In logistics, there's a concept called the "last mile problem." Getting a package from the distribution center to your front door — that final stretch — is disproportionately the most expensive and difficult part of the entire delivery chain. The infrastructure to move things across the country is efficient and well-optimized. But that final mile? That's where the complexity explodes.

In telecommunications, it's the same thing. Getting internet service near your house is hard enough — laying fiber across a city is a massive infrastructure effort. But getting that live, working connection from the street into your house and your neighbor's house and every other house on the block? That's a completely different scale of effort. That's Real Work with capital letters.

AI has exactly the same problem.

That last 20% — the part where you go from "this mostly works" to "this is actually right" — that's where the real expertise lives. And that part hasn't gotten easier. In some ways, it's gotten harder.

Here's what the last mile looks like in practice:

It's the subtle bug that only shows up in production — or even in development — because the failure requires three or four things working in concert to entirely not work together. AI coding assistants often can't see these because they're solving one problem at a time. But real systems fail at the intersections. The code compiled. The tests passed. But the behavior is wrong in a way that requires understanding the whole system to even notice.

It's hallucinations. They happen less often than they used to, but they're not gone. AI will confidently generate code that calls a method that doesn't exist, references a configuration option that was never real, or uses an API that works differently than how it was invoked. If you're not watching for them — and you've got to be watching for them — they'll sail right past you into production.

It's the unit tests that don't actually test anything. This one's insidious. AI writes the implementation and the tests at the same time, and the tests run and pass. Looks great. But when you actually read them, the tests aren't really validating anything meaningful. They're testing that the code does what the code does — which is circular. If you practice test-first development, you write the failing test before the implementation. That discipline forces you to think about what "correct" actually means. When AI writes both at once, it's the testing equivalent of self-dealing. Everything checks out because the same entity is setting the standard and meeting it.

It's the architectural decision that seems fine in isolation but creates a maintenance nightmare six months from now. AI is great at solving the problem in front of it. It's terrible at understanding how today's solution interacts with the twelve other constraints that nobody wrote down.

It's the requirements conversation where you realize the feature description was ambiguous and two reasonable people would interpret it differently. AI picked one interpretation. It might not be the right one. And you need to actually understand the business to know which one matters.

It's the code review where everything looks correct but something feels off — and it takes years of experience to articulate why.

That's the last mile. That's the part that was always hard. And AI didn't make it easier. AI just got you to the starting line of the hard part faster.

The Last Mile Has a Time Dimension Too

Here's the part that sneaks up on you.

The last mile isn't just the gap between "mostly works" and "actually right" at the moment you build something. It's also the gap that opens up over time.

You fire-and-forget a task to AI. The result looks good. You check it off your list. You move on. Six months later, you come back to that code and discover a really janky choice that was made on your behalf — something where you think, "wow, that's not how I would have done that." But it's baked in now. It's load-bearing. Other things depend on it.

You were perfectly fine with the results at the time. You just didn't know what you didn't know.

And this gets worse with maintenance. AI is arguably at its best working from a blank slate — that's where the first 80% is most impressive — going from nothing to something is miraculous. But most software work isn't greenfield. It's maintaining, evolving, and extending things that already exist.

And here's the structural problem: AI systems are essentially giant statistical prediction engines. They're really focused on what's next. Given what's here, what's the most likely next step? That means doing maintenance with agentic AI tends to produce an accumulation of incremental evolutions based on what was there before. Patch on patch. Layer on layer. And if you're not careful, that turns into a ball of tape, lint, and Band-Aids.

Sometimes when you're doing maintenance, the right answer isn't to evolve what's there. It's to step back and completely rethink the approach. Rip something out and rebuild it. Simplify instead of extend.

That's a judgment call. That's a human call. And it's the kind of call that AI's "what's next" bias actively works against — because statistically, "next" almost never means "start over."

That's the last mile in the time dimension. And most organizations won't see it coming until they're already deep in the tape-and-Band-Aids phase.

What Practitioners Actually Do With AI

Here's something the executives aren't seeing.

When I use AI to help me write code, I'm not handing it a task and accepting the result. I'm collaborating. I'm steering. I'm catching things. I'm saying "no, not like that — here's why" and redirecting. I'm taking what it gives me and reshaping it based on things I know that it doesn't.

And honestly? This is actually way more fun — real collaboration instead of bland, vacant-stare vibe coding. (And I like to think that the coding agent has more fun, too. Btw, treat your AIs nicely and maybe they'll spare your life when the Singularity hits.)

I'm using my judgment to evaluate every piece of output. And I'm doing that constantly — not as a final review step, but as an ongoing, continuous part of the process.

That's not "AI did the work and I checked it." That's me doing the work with AI as a tool. The expertise is still driving. The AI is making some parts faster. But the hard parts — the decisions, the judgment calls, the "wait, that's not quite right" moments — those are still mine.

And here's the thing: I can only do that because I already know what I'm doing.

If I didn't understand the architecture, I couldn't catch the structural problem. If I didn't understand the domain, I couldn't spot the wrong interpretation. If I hadn't spent years learning what "good" looks like, I wouldn't know when AI hands me something that's merely "plausible."

The AI makes me faster. It doesn't make me unnecessary. It definitely doesn't replace what I know.

The Executive Misread

The disconnect I keep seeing — in conversations with engineering leaders, HR executives, people on airplanes — is this: executives see the first 80% and assume the job is 80% done.

It's not. The first 80% was always the straightforward part. It was time-consuming, sure. But it wasn't where the hard thinking happened.

(Side note: the people who say that "SaaS is dead because of AI" haven't lived through having to maintain a deployed, system-critical software system before. That take is pure first-80% thinking.)

The last mile is where the value is. It's where the judgment calls happen. It's where domain expertise, institutional knowledge, and hard-won experience actually matter. And AI doesn't do that part.

What AI does is get you to the last mile faster. Which is great — if you have people who can run the last mile. If you have the expertise in the building to evaluate, adjust, correct, and refine what AI produces.

But if you've cut the people who could do that? If you've optimized away the expertise because "AI handles it now"?

You've just gotten to the hard part faster with nobody who knows how to finish.

The Skill Nobody's Talking About

Using AI well is itself a skill. And it's a different skill than most people think.

It's not "knowing how to write prompts." It's knowing enough about the domain to steer the AI in the right direction, catch it when it drifts, and recognize when its output is subtly wrong. It's the ability to hold the standard — to know what "right" looks like and refuse to accept "close enough" when close enough isn't good enough.

That's a skill that comes from experience. From doing the work. From building the judgment that lets you evaluate what AI gives you.

And the irony is, the better you are at this skill, the more it looks like AI is doing all the work. Because you're steering so naturally, so continuously, that the collaboration is invisible. The output looks effortless. The casual observer sees the AI producing great results and thinks, "why do we need the human?"

You need the human because the human is doing the last mile. You just can't see it.

After all, coding isn't just glorified typing.

What This Actually Means

I'm not anti-AI. That would be like being anti-power-tools. (Although, for the record, I am anti-processed-food. I'm totally onboard with the Slow Food movement and I typically make my own mayonnaise. So maybe I'm not the best person to use power tools as a metaphor for uncritical adoption.) AI is a genuinely powerful tool that makes me more productive every single day.

But it's a tool. And like every tool, it's most powerful in the hands of someone who knows what they're doing. A table saw makes a skilled carpenter faster. It doesn't make someone who's never built furniture into a carpenter.

(Also, making your own mayonnaise isn't that hard but the results are way better. You should try it.)

The last mile is real. The expertise matters. And the organizations that figure this out — that invest in the people who can run the last mile instead of assuming AI eliminated it — those are the ones that are going to build things that actually work.

The rest are going to get to 80% really, really fast.

And then wonder why nothing ever quite works right.