Look, I’m going to be direct here. If you are not using AI agentic coding methods right now - today - you are going too slow. Not “a little behind.” Not “maybe missing something.” Too damn slow.
I know, I know. You’ve heard this before. “This changes everything.” I’ve been coding since BASIC on a TRS-80 with 4K of RAM. I’ve watched every hype cycle come and go. Java was going to change everything. The web. Mobile. Cloud. I’ve heard it all.
This time it’s actually true. And it’s not a subtle change. It’s a sea change. It’s a tsunami.
The Genie Is Out of the Bottle
Let me say this plainly: the move to agentic AI methods is no longer “yeah, I’ll look at that soon” or “sure, I use that for some things.” That ship sailed. It’s gone. The engineers and teams who are already using these tools aren’t waiting for you to catch up. They’re shipping. They wished for “I want to ship products faster!” and the genii said yes. And gave it to everyone (who tries).
The genie is out of the bottle. You don't get to put it back.
I’ve been writing about the tooling transformation, the three tiers of where this is heading, and why naysayers are mostly wrong. I’m not a newcomer to this argument.
But I’ve been way too polite about the urgency. Let me fix that.
What “Deliver Results” Actually Means Now
If you work(ed) at Amazon or were shaped by its culture, you know the Leadership Principles. Bias for Action. Deliver Results. Invent and Simplify. Customer Obsession.
The buzz-word today seems to be all about agency. Garry Tan said it a year ago: “Intelligence is on tap now so agency is even more important.” I wrote about this when he said it. So what is it, really?
It’s bias toward action over asking questions. When there’s a reasonable path forward, take it. Don’t ask for permission to do the obvious next thing. Own the outcome, not just the task. You’re responsible for the goal being achieved, not just for completing the specific steps you were handed. It means unblocking yourself. When you hit an obstacle, you find a way around it or through it — you don’t just stop and report the blockage. Making judgment calls. When information is incomplete (it always is), you make a reasonable decision and proceed, rather than waiting for perfect clarity.
The opposite of agency is learned helplessness — treating every ambiguity as a blocker, every decision as someone else’s to make, every obstacle as a reason to stop.
So what is agency in the context of using agentic AI tools? IT MEANS ACTUALLY USING THE TOOLS. NOW. And using them as fully as you can. It means being proactive about how to use them more, and faster, and better. It does not mean complaining about how it makes mistakes, or how it can’t refactor your code base, or how it takes away some of your joy of programming. Folks, that’s learned helplessness. Get over it. Find your agency.
Software engineering as a profession has always been fundamentally about one thing: delivering results. Not writing clever code. Not mastering the perfect architecture. Not debating tabs vs. spaces. Delivering. Shipping. Making the thing that customers use.
The human-only approach to that is just too damn slow now. Full stop.
I don’t mean that dismissively. I mean it literally. The tools have changed the physics of how fast software gets built. And if you’re building at human speed while your competitors build at AI-augmented speed, you’re not in the same race anymore.
A Saturday Morning
Let me give you a concrete example.
My team has a very complex - and many years old - JavaScript Node.js application. We are modernizing it to add some very cool new capabilities. But it’s a complex app with lots of promise chains and conditionals. And there are literally millions of instanaces of it running in the world. We *must maintain backward compatability. None of my team were here when it was written, or even the last few major revisions. Analyzing it to build a test framework before we refactor had been puzzling engineers for weeks - really good engineers - who were trying to understand the architecture, the data flows, the assumptions baked into the design. Weeks of reading, tracing, trying to build a mental model.
I sat down with Claude Code last Saturday morning.
Four hours later I had a complete architectural analysis: the component relationships, the data flow patterns, the places where the design made sense and the places where it was going to bite us. The implicit contracts that existed between modules. The debt. The strengths. Oh, and 12 bugs we had missed.
Four hours. Not four weeks.
This is what agentic coding actually does. It’s not just writing new code. It’s understanding complex systems at a speed that was simply not possible before. The agent can hold more context than any single human can. It can trace execution paths. It can see patterns across a whole codebase simultaneously.
It can also collapse the “what if” to minutes. “Explain how we would port this particular part to go using a strangler-fig approach and what additional tests we need to make sure we don’t break existing functionality.” Bang. Not weeks. Minutes.
I’m not alone in discovering this. Engineers across the industry are finding that one of the most powerful uses of AI agents isn’t writing greenfield code - it’s understanding old code. Complex, undocumented, terrifying code. The kind that’s been passed down through five engineering teams and has the bones of three different architectural decisions buried inside it.
Agents are remarkably good at this. Human developers, working alone, are remarkably slow at it.
Caveat: you need really good prompts/skills to get the agent to give you good results. My experience and knowledge of our product let me dig and poke and prompt and check - it wasn’t a single prompt. It’s not a magic wand. It’s a power tool. We can talk about that later. Let’s not get distracted from the message of today.
Breunig’s Lessons, My Translation
David Breunig just published 10 Lessons for Agentic Coding and it’s worth your time. Let me pull out the pieces that hit hardest:
“Implement to Learn.” Build to understand, not just to ship. Experiments and analysis are now FAST.
“Agents Amplify Experience.” This is the one that matters most. Experienced engineers embed their hard-won intuition into prompts - the right terminology, the right framing, the edge cases that bite you. I could not have gotten the analysis I discussed above if I didn’t have the experience to guide the agent. It’s also why vibe-coding will never replace us.
“Find the Hard Stuff.” Don’t waste your AI on the boilerplate. Use it there, sure, automate the easy stuff. But the real value is in the hard problems - design, performance, security, architecture. That’s where your judgment matters, and the agent makes you move faster on it.
“Remember Hidden Costs.” Agentic code is “free as in puppies.” The generation is cheap, but maintenance isn’t. Think before you generate 10,000 lines of code you’ll never fully understand. This is real. Don’t be an idiot about it.
The through-line in all ten lessons: this isn’t about replacing your judgment. It’s about moving faster with your judgment. Agents amplify what you already know. They don’t substitute for knowing anything.
That’s worth saying again: it’s about moving faster with your judgment. Human in the loop. But dude, it’s about moving FASTER.
The Speed Problem Is Not Going Away
Here’s what keeps me up at night: we are late to the party. Almost all of us.
Fortune reported that 100% of code at some AI labs is now AI-written. Microsoft and Google are both over 30% and climbing. Y Combinator’s Winter 2025 cohort? 25% of those startups have codebases that are 95% AI-generated - and these are technical founders who could write it themselves.
They’re choosing not to. Because it’s faster.
Same engineer. Different tools. Different results.
The productivity gap between AI-augmented and human-only teams is not narrowing. It’s widening. Every week the tools get better. Every week the gap grows.
If your answer to this is “we’ll catch up later” - later is now. And you better pray you are not too late already. I pray that my team are not too late already. And blogs like this are just one way I’m trying to do something about it.
What You Need to Do
I’m not going to give you a twenty-step framework. Here’s the short version:
Pick up the tools. Seriously use them. Today.
Not “try them on a toy project.” Not “ask them to write a fibonacci sequence and complain when it’s imperfect.” Actually incorporate Claude Code or Cursor or whatever resonates with you into your real work for two solid weeks. Don’t knock it until you’ve really tried it.
Today! Do it today!
Build a dot-agents style configuration - your personal workflow and rules that make the agent actually work the way you want. I wrote about this at length. The workflow around the model matters more than the model.
Build YOUR workflow. Be detailed. Read the workflows that others built. Don’t just use mine or anyone elses. Build YOURS.
Oh, and revise that often. I can already tell you that my dot-agents folder is out of date with my new knowledge. You HAVE to keep that stuff current. The era of revising your tooling once a year is also gone.
The Genie Doesn’t Go Back In
I’m a Navy veteran. We had a saying: “Train like you fight.” In peacetime, you build the habits and skills that carry you when the stakes are high. You don’t wait until you’re actually in a fight to figure out your equipment.
The software equipment has changed. Train like you fight.
The profession of software engineering is about delivering results. The tools that let you deliver faster, understand faster, build faster - those tools are here. Using them isn’t optional anymore. It’s what “Deliver Results” looks like in 2026.
Get sh*t done. It’s that simple.
The genie is out of the bottle. You don’t get to put it back. And honestly? Once you really use these tools - I mean really use them - you won’t want to.