I was in a conversation recently with a senior engineering leader at Microsoft. He mentioned, almost in passing, that their development teams now carry an internal target: generate 50% of production code using AI tools.
Not a stretch goal. A target.
I've been thinking about what that actually means for the working engineer — not the headline version, but the granular, day-to-day reality of what changes and what doesn't.
What the 50% number is measuring
First, let's be precise about what "50% AI-generated code" means, because the metric itself is underspecified.
Is it 50% of lines committed? 50% of characters? 50% of files touched in a sprint? Does a human-edited AI suggestion count as 50% AI or 0%?
At most orgs tracking this, "AI-generated" means code that was initially produced by a copilot or agent tool and accepted by the engineer — even if subsequently edited. On that definition, the number at many teams is already 30–40% for greenfield work. Getting to 50% is less a technological leap than a cultural one: making it the default path rather than the optional tool.
What actually changes at 50%
Code review shifts in shape, not volume. If anything, the review burden increases. AI-generated code tends to be syntactically correct and structurally conventional, which makes reviewers lower their guard. The bugs that slip through are not the obvious ones — they are the subtle semantic ones, the hidden invariant violations, the race conditions that only appear at scale. Teams that hit 50% without updating their review practices will ship more of these.
The senior/junior dynamic changes. Junior developers using AI tools can produce code at a velocity that previously required years of pattern recognition. But velocity without judgment is dangerous. The role of the senior engineer is no longer primarily to write code faster — it is to provide the judgment layer that AI cannot: understanding what invariants the system is actually maintaining, catching the plausible-but-wrong output, knowing when the generated code misunderstands the domain.
Accountability attribution gets murky. When a bug ships in AI-generated code, who owns it? The engineer who accepted it? The team lead who approved it in review? The org that set the 50% target? This is not an abstract question — it will show up in post-mortems, in performance reviews, and eventually in liability discussions. Orgs haven't caught up with the governance implications.
Documentation pressure increases. AI tools generate code from context. The less context your codebase has — through comments, docstrings, README files, meaningful variable names — the worse the generated output. Teams chasing the 50% target without investing in documentation quality will find the AI generating plausible code that increasingly doesn't fit the actual system.
What doesn't change
The actual hard parts of software engineering remain human. Deciding what to build. Understanding the user's real problem, which is usually not the stated problem. Navigating the organisational constraints that shape what's technically possible. Making judgment calls under uncertainty with incomplete information.
These are not prompt-engineering challenges. No amount of AI code generation changes them.
The thing worth worrying about
The target creates an incentive structure. If teams are measured on "% of code AI-generated," engineers will find ways to hit the number — including accepting AI output they'd otherwise revise, or framing human-written code as AI-assisted.
Metrics shape behaviour. The 50% target is a reasonable directional signal but a poor KPI. The better question is: what is the defect rate, cycle time, and system reliability of the code being shipped, regardless of how it was produced?
The exec I spoke to understood this. His point was not "AI should write half your code." His point was "if your team isn't regularly using AI as a core part of the workflow, that's a capability gap we need to close."
That's a more nuanced position than the headline number suggests — and it's the right one to hold onto as these targets propagate across the industry.
Top comments (0)