GitHub Copilot writes 46% of your code. But who is responsible for the other 100%?
That question is not rhetorical. According to GitHub's own data, AI coding assistants now generate an average of 46% of developer code — and up to 61% in Java projects. More than 75% of professional developers reported relying on AI for at least one daily task in 2024, according to the DORA Accelerate State of DevOps Report.
The headlines write themselves: AI is replacing developers. Studios are obsolete. You can build a product with a chatbot and a weekend.
The data tells a different story.
The productivity paradox hiding in plain sight
The 2024 DORA report found something counterintuitive. While AI adoption correlated with improvements in individual developer flow and job satisfaction, scaling AI across an organization was associated with a 1.5% decrease in delivery throughput and a 7.2% decrease in delivery stability.
Let that sink in. More AI adoption, less stable software delivery.
The mechanism is straightforward once you understand it. AI makes writing code frictionless, so developers write more of it, faster, in larger batches. Larger changesets mean harder code reviews. Harder code reviews mean slower merges, more merge conflicts, and more deployment risk. The speed gain at the keyboard evaporates downstream in the pipeline.
GitClear's independent analysis of hundreds of millions of lines of code reached a parallel conclusion. Code churn — the rate at which recently merged code gets reverted, rewritten, or substantially changed — roughly doubled in AI-assisted projects, climbing from a historical baseline of around 3.1% to between 5.7% and 7.1%. At the same time, refactoring activity collapsed. For the first time in their dataset's history, copy-pasted code within commits outnumbered refactored and moved code.
In plain terms: AI writes more code, faster, and more of it needs to be fixed shortly after.
The 20/80 problem of software engineering
Writing code is roughly 20% of what software engineering actually is. The other 80% is the hard part:
- Understanding what a client actually needs (which is rarely what they say they need)
- Translating vague business goals into concrete architecture decisions
- Deciding what not to build
- Reviewing what AI generated and catching the errors it made with confidence
- Owning deployments when something goes wrong at 2am
- Managing technical debt so the codebase stays maintainable in year three
- Ensuring the product is accessible, performant, and secure
AI handles the typing. None of the above is typing.
The Stack Overflow 2024 Developer Survey reinforced this: despite over 63% of developers actively using AI daily, approximately 39% reported little to no trust in AI-generated code. These are the same people using the tools. They know firsthand what gets through undetected when there is no human review.
What AI actually cannot do (yet)
Context is the hard problem. Modern AI models have large context windows, but they still lack what an experienced engineer carries into every project: years of opinionated knowledge about what patterns age well, which dependencies become liabilities, what architecture choices will hurt at scale, and why that legacy module nobody touches exists in the first place.
AI hallucinates. It generates code that looks correct and compiles cleanly but contains logic errors, security vulnerabilities, or calls to APIs that do not exist. A 2024 study on AI-generated code found that a meaningful percentage of AI suggestions introduced security vulnerabilities not present in human-written equivalents — particularly in areas like input sanitization, authentication flows, and error handling.
AI cannot negotiate. Client requirements are almost never precise. 'We need something that feels fast and modern and fits our brand' is not a prompt. It is a conversation — one that requires reading the room, asking the right follow-up questions, managing expectations, and sometimes telling a client their instinct is wrong.
AI cannot be accountable. If an AI-generated deployment leaks user data or crashes a production system, the AI does not answer for it. A studio does.
What AI changes about how studios work
The strongest studios in 2025 are not ignoring AI. They are using it as a force multiplier and becoming better at the work AI cannot do.
Boilerplate, test scaffolding, documentation drafts, repetitive API structures — these are now faster. An engineer who would have spent a day writing CRUD endpoints can do it in an hour. That hour gets redirected toward code review, architecture planning, performance auditing, and the detailed product conversations that determine whether the right thing gets built.
The DORA report framed this shift precisely: developers are moving from coders to architects, from creators to curators. The role of a studio is not to type code as fast as possible. It always has been, and increasingly is, to make the right decisions about what to build and to be responsible for what ships.
AI accelerates execution. Judgment, accountability, and craft are still what you are hiring for.
The specific skills that compound
What distinguishes a studio that uses AI well from one that produces unmaintainable code faster?
Architectural thinking. Knowing when to use a monolith versus microservices. When server-side rendering is worth the complexity. When a simple spreadsheet is a better solution than a custom backend. These decisions happen before a single line is written.
Performance engineering. AI can write code that works. It rarely writes code that is fast. Core Web Vitals, LCP optimization, bundle analysis, and cache strategy require deliberate expertise that does not emerge from prompting.
Security awareness. AI-generated authentication flows, input handling, and API design require scrutiny. Vulnerabilities in AI-generated code tend to cluster in exactly the areas where the consequences of a mistake are highest.
Long-horizon maintenance. A codebase that looks clean at launch can become unnavigable in 18 months if the architectural decisions were wrong. Studios with experience have seen this happen and build differently as a result.
Communication and trust. The most consistently undervalued skill in software development is the ability to translate between what a business needs and what a developer builds. No AI tool has solved the gap between a business requirement and a technical specification.
Sources
- GitHub Copilot code generation statistics: GitHub, GitHub Copilot: The AI pair programmer (2024) - github.com/features/copilot
- DORA 2024 AI findings (75% adoption, delivery throughput decrease, stability decrease): Google DORA, Accelerate State of DevOps Report 2024 - dora.dev
- GitClear code churn and duplication findings: GitClear Research, Coding on Copilot: 2023 Data Suggests Downward Pressure on Code Quality (2024 update) - gitclear.com
- Stack Overflow Developer Survey 2024, AI tool adoption and trust data - survey.stackoverflow.co
- AI productivity paradox (Harvard/Jellyfish analysis): InfoQ, AI Assistants Boosted Code Volume But Not Feature Delivery (2024) - infoq.com
- GitHub Copilot Java language statistics: Medium / secondtalent.com, AI Coding in 2025: What the Data Actually Shows - secondtalent.com
- DORA batch size analysis: InfoQ, 2024 DORA Report: AI Boosts Individual Productivity but Creates Systemic Risks - infoq.com
Work with me
Want to build something like this?
I build, optimise, and ship for teams who need it done right. Free project scoping, full code ownership.