8/11/2025

Code Isn't the Problem: Why We're Focusing on the Wrong Bottleneck in Development

Hey everyone, let's talk about something that's been on my mind a lot lately. For years, the story in software development has been all about speed. "If only we could write code faster," the thinking goes, "we could ship more features, beat the competition, & change the world." We've built entire industries around tools, methodologies, & frameworks designed to help developers type faster, automate snippets, & basically turn ideas into code at lightning speed.

And then, AI came along & blew the doors off.

With tools like GitHub Copilot, Claude, & others, developers can now generate huge blocks of code in seconds. The dream, it seems, has been realized. The bottleneck of actually writing the code has been annihilated. Or has it?

Here’s the thing, and it's a big one: writing code was never really the bottleneck. Honestly, it's a myth. The real slowdowns, the things that actually keep features from shipping & projects from launching, are everything that happens around the code. And the crazy part? Our new AI superpowers might be making those real bottlenecks even worse.

Let's dig into what's really going on, because understanding this is KEY to actually getting better & faster at building software.

The Old Myth: The Lone Coder in the Dark

Picture the classic image of a developer: a lone genius, headphones on, bathed in the glow of a monitor at 2 AM, chugging energy drinks & typing furiously. In this picture, the only thing standing between an idea & a finished product is the developer's ability to translate thought into syntax. Their typing speed, their knowledge of libraries, their raw coding stamina—that was the perceived limit.

This image led to a focus on individual developer productivity. How many lines of code did you write? How many tickets did you close? It was a factory-floor mentality applied to a creative, problem-solving discipline.

But anyone who's actually worked on a software team knows this is a fantasy. Software development is not a solo sport; it's a team effort, & the act of typing is just one small piece of a much, much larger puzzle.

The Reality Check: Where Your Time Really Goes

So if it's not the typing, what is it? Turns out, the real bottlenecks are the messy, human, & deeply complex parts of the process. These are the things that can't be so easily measured or automated away.

Bottleneck #1: Understanding & Code Reviews

This is the big one. As Pedro Tavares put it, "The biggest cost of code is understanding it — not writing it.” Think about it. Before you can even write a line of code, you have to understand the problem you're trying to solve. You have to understand the existing system you're plugging into. You have to understand the requirements, the edge cases, & the potential side effects.

Then comes the review process. A pull request with 500 new lines of code doesn't just get waved through. Someone else on your team has to stop what they're doing, pull down your changes, & try to load the entire context of your work into their brain. They have to ask:

Does this code do what it's supposed to do?
Does it do it in a way that aligns with our team's standards?
Does it introduce new security risks or bugs?
Is it maintainable? Will we be able to understand & fix it two years from now?
Are there any "unknown unknowns" lurking in here?

This cognitive load is IMMENSE. It requires deep thought, careful consideration, & often a back-and-forth conversation. The act of writing the code might have taken a few hours. The act of reviewing & approving it can take days, especially with the labyrinth of planning meetings & agile rituals we've built around the process.

Bottleneck #2: Testing, Debugging, & Quality Assurance

So your code is finally reviewed & merged. Great! Now you have to test it. And I don't just mean a few happy-path unit tests. I mean integration tests, end-to-end tests, performance tests, security scans—the whole nine yards.

This is where the gremlins hide. The code might work perfectly on your machine, but it breaks in the staging environment. A change you made over here has an unexpected & catastrophic effect over there. Finding these bugs is detective work. It's about tracing logic, digging through logs, & trying to reproduce intermittent issues. It's time-consuming, frustrating, & absolutely critical.

And what happens when we use AI to generate code? We often get more code, which means a larger surface area for bugs to hide in. One study found that 67% of developers spend more time debugging AI-generated code, & 68% spend more time resolving security vulnerabilities that pop up from it. The code looks polished on the surface, but can be much more broken underneath, which breaks the pattern-matching that experienced devs rely on to spot issues quickly.

Bottleneck #3: Communication, Coordination, & The Human Overhead

Software engineering has always been collaborative. It’s about people. It's about planning meetings where you try to align on what to build. It's about daily stand-ups to sync on progress. It's about Slack threads that go on forever to clarify a single requirement. It's about mentoring junior developers & transferring knowledge so the team gets stronger.

This "human overhead" is often seen as a distraction from the "real work" of coding, but it is the real work. Without shared understanding & alignment, you get developers building the wrong things, duplicating effort, or creating solutions that don't fit together.

As one developer put it, a lot of the frustration isn't about building, it's about waiting. "Waiting for infra, approvals, or some process that exists 'just because'." You're stuck in a queue, blocked by dependencies on other teams or bureaucratic processes. AI can't write code to solve that.

Enter AI: The Great Accelerator or The Great Amplifier?

This brings us back to our shiny new AI tools. They promised a massive productivity boost. JPMorgan Chase claimed their efficiency jumped by "as much as 20%," & an Atlassian report found many developers saving over 10 hours a week. Developers using these tools report feeling happier, more in flow, & more focused on satisfying work. Pretty cool, right?

But the story isn't that simple. Another study found that developers, despite predicting they'd be 24% faster with AI, were actually 19% slower at completing tasks. How can this be?

Because AI doesn't remove the workload—it just shifts it. It's an amplifier.

When you're working on a brand new project from scratch (a "greenfield" project), writing code is often the bottleneck. In that scenario, AI is a godsend. It blows the doors wide open, letting you prototype & build things at a staggering pace.

But most developers don't work in greenfield projects. They work on existing, complex systems with years of history & technical debt. In that world, generating huge swaths of code with AI only exacerbates the real bottlenecks. You get:

More Code to Review: Your team is now flooded with AI-generated pull requests, putting immense pressure on reviewers who have to verify code they didn't write & might not fully understand.
More Code to Test: The volume of code increases, & so does the potential for subtle, hard-to-find bugs.
More Code to Maintain: Someone has to own this code for the long term. If the original author just used an AI prompt & doesn't deeply understand why the code works the way it does, good luck fixing it a year from now.

We've basically reduced the marginal cost of producing software to near zero, but the cost of understanding, testing, & trusting that software is now higher than ever. We're creating piles of "ascii-encoded-binaries" in our source control, where even the source code prompt isn't written down.

Shifting Our Focus: How to Actually Speed Up

So what's the answer? Do we throw away the AI tools? No, of course not. They're incredibly powerful. The key is to stop focusing them on the wrong problem. Instead of just using AI to generate more code faster, we need to use it to attack the real bottlenecks.

Imagine an AI that doesn't just write your code, but helps with the review process by:

Summarizing the key changes in a large pull request.
Highlighting potentially risky areas or deviations from standard patterns.
Suggesting specific edge cases that need to be tested.

Imagine an AI that helps unblock you by navigating the internal bureaucracy. An AI that can pre-validate checklists, catch configuration & security issues before the review, & help you get through the approval process faster. That's where the REAL productivity gains are hiding.

This is where the concept of internal knowledge management becomes CRITICAL. The biggest slowdowns often come from trying to find information. What's our policy on this? Where is the documentation for that service? Who do I need to talk to about getting infrastructure access? This is knowledge transfer, a key bottleneck.

This is precisely the kind of problem where a solution like Arsturn comes into play. Imagine your business creating a custom AI chatbot trained on ALL of your internal data—your Confluence pages, your engineering wikis, your architectural decision records, your code standards, even your past pull request discussions.

Now, a developer doesn't have to wait for an answer or interrupt a senior engineer. They can just ask the chatbot:

"What's our preferred library for real-time notifications?"
"Show me the standard deployment process for a new microservice."
"What were the security concerns raised the last time we implemented a third-party payment gateway?"

Suddenly, you're not just automating code; you're automating access to information. You're tackling the communication & knowledge transfer bottleneck head-on. Arsturn helps businesses build these no-code AI chatbots that can provide instant, accurate answers 24/7, freeing up developers to focus on the strategic work that matters, not waiting in a damn queue. It helps build a shared context & ensures that institutional knowledge doesn't just walk out the door when someone leaves.

When you start thinking this way, you realize the future of developer tools isn't just about making the individual faster; it's about making the team smarter & more connected.

The Future is About Thinking, Not Typing

The bottom line is this: the craft of software development is changing. The value an experienced developer brings is no longer about their ability to write code quickly. That's becoming a commodity.

The real value—the real skill—is in everything else:

Problem Solving: Deeply understanding a user's need & designing an elegant, simple solution.
System Design: Thinking about how all the pieces fit together for a robust, scalable, & maintainable system.
Collaboration: Communicating effectively, building trust, & mentoring others to elevate the whole team.
Judgment: Knowing when to use an AI-generated solution, when to push back, & when to spend the extra time to ensure quality.

We're moving from a world where we were bottlenecked by our typing speed to one where we're bottlenecked by our ability to think critically, communicate clearly, & manage complexity. Good experienced devs will be able to make better software, but they'll also be under more pressure to deal with the flood of lower-quality software being produced.

The challenge for all of us—from junior developers to engineering leaders—is to recognize this shift & adapt. We need to value understanding over raw output. We need to invest in tools & processes that improve communication & collaboration. And we need to learn how to use our powerful new AI tools not as a crutch, but as a scalpel, applied surgically to the parts of the process that truly slow us down.

Hope this was helpful & gives you something to think about. Let me know what you think the biggest bottlenecks are on your team