AI coding is no longer limited to autocomplete. Google now documents both agent mode in Gemini Code Assist and terminal-based Gemini CLI workflows, where the system can use tools, read files, write code, and work through multi-step tasks. Gemini CLI is described by Google as an open-source AI agent for the terminal, using a ReAct loop plus built-in tools and MCP servers to fix bugs, create features, and improve test coverage. In Gemini Code Assist agent mode, Google also explicitly says developers can give high-level goals, review plans, approve tool use, and let the agent generate code from design docs, issues, and TODO comments.
That matters because it changes the shape of software work. The question is no longer, “Can AI help engineers write code faster?” It clearly can. The harder question is whether this creates real engineering throughput, or whether it simply moves the pressure downstream into review, testing, debugging, security, and operational reliability. That is where the current shift becomes interesting.
From code authoring to code supervision
The clearest sign of this shift is how fast companies are moving from assistance to delegation. According to Uber CTO Praveen Neppalli Naga, 95% of Uber engineers now use AI monthly, and Uber’s internal coding agent is producing around 1,800 code changes per week with “zero human authoring.” Engineers review and approve the output, but the code itself is written by AI agents. He also said the share of AI-generated code changes at Uber has grown from under 1% to 8%.
This is a meaningful change in role design. Engineers are still responsible for the system, but increasingly not for typing every line. Their work shifts upward: specifying intent, setting constraints, checking architecture, validating correctness, and deciding whether machine-generated output is safe to merge. In other words, software engineering starts to look less like raw code production and more like orchestration plus governance.
Yes, productivity is real
There is real upside here. GitHub’s early Copilot research found that developers completed tasks faster and reported higher satisfaction when using AI assistance. More recent enterprise-scale evidence points in the same direction: a 2025 real-world study covering 300 engineers over a year reported a 31.8% reduction in PR review cycle time, stronger code shipment volume, and high satisfaction with AI-assisted workflows.
So the productivity case is not imaginary. AI is very good at draft generation, repetitive implementation, scaffolding, boilerplate, straightforward refactors, test generation, and speeding up “blank-page” work. It is especially effective when the task is narrow, the context is clear, and the acceptance criteria are well defined.
That is why teams adopting AI coding often feel an immediate boost. More code gets produced. Small features move faster. Engineers can parallelize work by assigning multiple subtasks to tools or agents. For many organizations, this is the first visible win.
But productivity at the keyboard is not the same as delivery performance
The harder lesson is that faster code generation does not automatically translate into better software delivery. Google Cloud’s 2025 DORA report makes this explicit. Based on research involving nearly 5,000 technology professionals, the report argues that AI acts primarily as an amplifier: strong teams get more leverage, but weak systems get their weaknesses exposed faster. DORA also found that while AI adoption shows a positive relationship with throughput and product performance, it still has a negative relationship with software delivery stability. Google’s explanation is blunt: AI accelerates change volume, and without strong testing, version control, feedback loops, and platform foundations, that extra speed creates instability downstream.
That is the core systems issue.
If AI lets you generate implementation faster than your organization can review, validate, and safely release it, then code was never the real bottleneck. The bottleneck just moved.
Where the bottlenecks move
The first bottleneck is review. AI can produce code quickly, but someone still has to check whether it is correct, maintainable, secure, and aligned with architecture. When code volume rises faster than reviewer capacity, PR queues can become the new drag on delivery. In that world, the scarce skill is no longer syntax production. It is judgment.
The second bottleneck is testing. Generated code can look plausible while still being subtly wrong. The more AI increases change volume, the more teams need reliable automated tests, good staging environments, and fast regression feedback. DORA’s findings strongly support this: teams with mature engineering foundations benefit more, while weak foundations turn speed into instability.
The third bottleneck is reliability. Agentic tools can change more files, span more contexts, and take more actions than a traditional autocomplete assistant. Google’s own agent-mode documentation warns that changes outside the IDE may not be undoable and that auto-approving machine actions requires caution because the agent can access file systems, terminal actions, and configured tools. That is powerful, but also a reminder that the cost of a bad action is larger when the tool operates with more autonomy.
The fourth bottleneck is system understanding. AI is strong at local code transformation, but production systems fail at boundaries: cross-service contracts, migration sequencing, data assumptions, concurrency, rollout strategy, permissions, observability, and rollback design. Those are still human-heavy responsibilities. As autonomy rises, engineering value shifts toward understanding the whole system rather than just implementing one function inside it.
So, does AI coding increase productivity?
Yes, but unevenly.
It increases productivity most when teams already have clear standards, good CI, strong code ownership, reliable tests, and enough architectural discipline to evaluate machine output quickly. In those environments, AI compresses the low-value portion of the work and frees engineers to spend more time on system design, trade-offs, and product decisions.
It creates less value when teams are already overloaded with fragile systems, weak review practices, poor test coverage, and unclear ownership. In those cases, AI may generate more code, but not more confidence. The result can feel like acceleration while actually increasing hidden operational risk.
That is why the debate should not be framed as “AI replaces engineers” or “AI makes engineers 10x faster.” The more accurate framing is this: AI compresses code authoring, but expands the importance of review, architecture, testing, and governance.
The changing role of the software engineer
The role is not disappearing. It is becoming more selective and more senior in nature.
Tomorrow’s strong engineers will still need to code, but their real differentiator will be the ability to define tasks well, decompose work, evaluate generated output, spot failure modes, design reliable systems, and enforce production guardrails. In an AI-heavy environment, the valuable engineer is not just the fastest typist. It is the person who can keep the system coherent while machine output scales.
So the real answer to the blog angle is this:
AI coding does increase engineering productivity, but only if the surrounding engineering system is mature enough to absorb the extra speed. Otherwise, it simply relocates the bottleneck into review, testing, and reliability.
And that may be the most important shift of all. Software engineering is moving away from pure code creation and toward supervised system construction. The code may be increasingly machine-written. The accountability will not be.
References
- Google Cloud (2026) Use the Gemini Code Assist agent mode. Google Cloud Documentation.
- GitHub Blog (n.d.) Research: quantifying GitHub Copilot’s impact on developer productivity and happiness.
- Scammell, R. (2026) Uber CTO says it’s going big on AI coding: “This is a real reset moment for engineering”. Business Insider, 18 March.
