Why You're Only Getting 10% From AI Coding Tools

Everybody's arguing about AI productivity tools right now. Studies say 10% maybe 20% productivity gains and some developers are claiming to be 10 times more productive. Actually, right now both of those things are true. The differentiator is working with feedback loops inside the LLM in the middle of your workflow and positioning yourself as a builder of the feedback loop that builds code.

Most developers haven't built feedback loops with their LLMs yet. Today, we're going to talk about what it looks like before you hit that unlock moment, what changes when you reach it, and what after that unlock moment looks like. Most people start AI programming with some kind of chat interface. You ask it a question, maybe paste a block of code into it, and then you copy all that back into your code editor somewhere.

It's pretty slow and painful, but it already can feel productive because you got something back pretty quickly. You also get hit with all of the problems with this method at the same time. It doesn't generate what you want. It doesn't know what you want to do. It's fast. But it's very far from perfect and people get stuck here. If you want to look at previous generations of tools like Copilot or Cursor, it was basically an LLM acting as autocomplete inside of your editor.

You are still writing the code. It still suggests some code. You hit tab a few times and you end up in, you know, a pretty good place. It still feels fast. And to be honest, yeah, it can be faster than traditionally writing code and it's still prone to all those issues. Studies have shown this is 12 to 30% improvement on simple tasks, but we know it can't really handle the complex ones.

Not so well. At the same time, there have been studies that show developers who thought they were faster with AI tools were actually slower. The MER study recently came out and said experienced developers thought they were faster on their own codebase, but they were something like 19% slower on their own code base with AI tools. But the thing is those studies were not investigating how developers using modern agentic tools that exist in 2026 were used.

They were testing the capabilities of the autocomplete era systems. Those tools they studied are already out of date with the state-of-the-art by a very wide margin. And these are apples and oranges. We are going to get into why and I'm going to show you what that looks like. So you'll be working with AI tools in this autocomplete mode, getting minor gains until you hit an unlock moment.

And what actually changes in this unlock? And how do you know if you've reached it? Well, it's because you've stopped being the developer who writes code with AI as if AI is another tool. The same way you'd use spellch check or a llinter. It stops fitting into that category. You become the person guiding an AI that's writing the code for you. Afterwards, AI is doing the work.

The human is guiding and governing the system within which it happens. At this unlock moment, you've stopped working on the level of code and started working on the level of the system. A system which contains an AI agent that's good at writing code. It's not perfect, but it also contains everything else that gets put into the loop that converges on acceptable software.

not talking about developers making small performance improvements. We're talking about adopting a completely different working paradigm. Other people have mapped this kind of progression as well. Some people have fivestage models. Some people have eightstage models, but they all describe growing towards this flip point through automating your use of AI tools.

Reaching this flip and then working towards building more elaborate levels of guidance and orchestration. After you reach this flip, AI is writing the code and you are writing the guidance system. Now for me, the unlock came when I realized I could build a sort of machine out of the scaffolding, the tests, the specs, the rules, and I could just set it off on its own.

I could come back later and cover the things that it couldn't do and work with it to improve the system on a secondary loop. So there's a loop that I set it on and then there's the loop that I'm in to improve the loop that I set it on. Later I did a lot of digging and I discovered a lot of the thought leaders coming out now discussing improvements in the agentic development space are kind of rediscovering things that are quite old and well understood concepts in cybernetics.

The point is all of this knowledge made me incredibly more productive not only in how much more I could ship but in how ambitious I could be. entire fields where it would take me a long time to upskill became easily accessible to me. And now I can't look back at my old way of working with anything other than nostalgia. Here's what it looks like after the unlock.

A normal process is a long round of specifications where I describe the feature I want and the way I want the agent to do the work. That evolves into a rolling conversation until I am convinced there's enough context for the agent to make a very large amount of progress without asking me everything. The agent runs tests fail. It reads the errors. It fixes the code.

Tests pass. I didn't write any of that code. I might not have even written the tests. The agent wrote them per my specifications. The trick is to make it converge towards correct by defining enough specification of where the goal is and enough specification of how to navigate towards the goal. The instructions for how the agentic loop should operate.

One of the interesting things here is that the rules file, the context files, the things that I create through these conversational loops are more important than any of the code that I write. A lot of people are getting wise to this very quickly. The specifications, the instructions, the meta level that ends up being the real intellectual property.

It's the instructions for assembly of software systems. But it's not only that. It's also the agentic loop itself. If I uninstall Playright, things get worse. If I reinstall it, things get better really quickly. So, it's not only about prompting better. It's about creating the system. And that's the difference from prompting better because prompting better is not actionable feedback.

And it's quite annoying to hear. You need a way to structure your specifications. You need a way to manage your context. You need a way to build an agentic loop. And that's more than magic keywords sprinkled into a prompt as if you're making a wish of an LLM genie somewhere. You're going to want to figure out orchestration of multiple loops. And that's basically where you have your main session, your orchestrator that you work with directly.

And that orchestrator is going to kick off other sub aents to do different tasks that don't necessarily know about each other's work. Maybe they do. Possibly they could share information through different techniques, but they're all focused on different things. And if you take that to the next level, you realize there's a nested pattern where you could launch a feature orchestrator.

You could launch five of them in parallel. You could launch 10 of them in parallel. The only thing really limiting you here is your API rate limit, which I have hit. And you can have all of those things working and they can further orchestrate their own sub agents. And you'll want to do this for many reasons. One of them is your contact window. not only maxing out your tokens, but also preserving them.

And we're going to have a video on that topic later. But the point is, you begin to see many ways to create different branches of loops that reinforce each other and bring you towards a solution. Not only a higher quality solution, but a faster solution where the robot puts out something much faster. This is where productivity genuinely becomes transformative, but it's also where you get jagged productivity.

Some tasks fly and some don't. The drivers are the capabilities of the loop you've built, which is a product of the LLM, the MCPs, the skills, the agents, the context files, and the complexity and uniqueness of the task you're actually trying to take on, as well as your human skills in guiding that system through the complexity space. and understanding its limitations.

That's where jagged performance comes from. The current way we interact with AI, chatting with a session, I don't think that's going to survive as the default into 2028. The tools will change, the interfaces, these will all change. But the principles, the feedback loops, the specification work, the orchestration, these will outlast every current tool.

My advice for everyone in the space is to focus on learning the principles, not just the products. Don't pick a favorite product and think you're going to master it. And I don't think these products are going to stick around in the long run anyway. We're going to have a whole new era of tools that look completely different in just a few years. Let's also clarify expectations here.

10x productivity does not mean 10x revenue or business outcomes. You still need to build the right things. Just because you ship 10 times more features does not mean your customers suddenly care 10 times more. It doesn't mean they're going to give you 10 times more money either. In fact, you might be 10 times more confused about what's strategically relevant to your business.

This Agentic Unlock gives you speed, not direction. If your principal challenge is business strategy, come look at my other channel, Building Better Teams, where we talk about organizational leadership in detail. This unlock moment is real. It's learnable. And this whole channel here is going to help you learn how to build those systems in detail. I've got 50 videos planned already and I'm going to help you learn how to ship the loop in everyone.