Former Google Engineer with 15 Years' Experience: AI Coding Assistants Rekindled My Passion for Building

A seasoned engineer with 15 years in the software industry, three of which were spent at Google, recently posted on Reddit expressing that he's had enough of the anti-AI rhetoric. He acknowledges that AI has many problems, but he's frustrated by people pretending AI can't do what it's already doing. This article, based on his firsthand experience, explores how AI is changing complex debugging work and how developers should rationally view AI coding assistants.

Complex Debugging: From Days to an Afternoon

He gave an example of a C++ search service system: troubleshooting tail latency issues. Requests fan out via RPC to multiple backends, most complete quickly, but a few slow responses drag down the overall performance. The median latency looks normal, but p99 is terrible. A change that passes all basic tests can still crash under load.

What's trickier is that a slow RPC triggers a second request to another replica. The caller eventually times out, but the backend work continues. Under load, these extra requests fill up queues, making everything slower—the very mechanism meant to reduce latency instead exacerbates overload. Fixing it requires tracing deadlines along the call chain, checking cancellation, and limiting extra work. Then there's the C++ lifetime issue: if a completion callback can still run after cancellation, prematurely freeing request state introduces a use-after-free. Congratulations, the latency fix now occasionally crashes the process.

"This kind of task could eat up days back in 2016," he wrote. Reading unfamiliar code, comparing traces, digging through profiles, building reproducers because existing tests never covered that sequence, then another round of review because the patch fixed one path but broke another.

Tail Latency and p99: In distributed systems, latency is often described using percentiles; p99 means 99% of requests complete under that value, while the remaining 1% may be extremely slow. Tail latency focuses on these slowest requests—though few, they significantly inflate overall response time, especially in fan-out scenarios where one slow backend can drag down the entire request. The C++ search service in the article is a typical case: median is normal, but p99 spikes, indicating a few slow requests become the bottleneck.

RPC Fan-out and Timeout Propagation: RPC (Remote Procedure Call) fan-out means a request is distributed to multiple backend services for parallel processing. When a backend responds slowly, the caller may time out and retry to another replica, but the original backend's work continues, causing extra load. The deadline needs to propagate through the call chain so downstream can cancel useless work promptly; otherwise, queue backlog exacerbates overload.

Use-after-free and C++ Lifetimes: Use-after-free is a memory safety vulnerability where a program continues to use a pointer to memory after the object's memory has been freed. In asynchronous RPC, if a completion callback can still execute after cancellation while the request state has been prematurely freed, the callback accesses invalid memory, causing a crash. If cancellation logic introduced when fixing tail latency isn't properly handled regarding callback lifetimes, it can trigger such issues. This requires developers to carefully manage object ownership and callback lifetimes, for example using smart pointers or reference counting.

How AI Intervenes: From Manual to Supervision

Now, he hands the relevant implementation, traces, and constraints to Opus and immediately starts untangling the problem. He has the model trace request lifecycles across files, find where deadlines stop propagating, propose patches, and write tests that deliberately deliver callbacks after cancellation or simulate slow backends. His attention shifts to reviewing reasoning and test results.

"I'm still responsible for the fix. Production performance issues still require load testing. But getting a serious candidate patch is now much easier, and I have no interest in manually doing every step again," he said. Many tasks that used to bounce among multiple people for weeks can now be completed in an afternoon.

Over the past year, he's completed long-shelved projects, implementing these ideas while he still cares about them.

Opus and AI Coding Assistants: Opus usually refers to the Claude 3 Opus model launched by Anthropic, a large language model (LLM) with strong code understanding and generation capabilities. In such debugging scenarios, AI assistants can receive codebases, distributed traces, and performance profiles, perform cross-file reasoning, locate root causes, and generate patches and test cases. It's not automatic fixing, but a "candidate patch generator," with engineers reviewing the reasoning process and test results and ultimately being responsible for the fix.

What Anti-AI Rhetoric Ignores

The engineer's complaint isn't about AI's flaws, but about the pervasive "pretending" in conversations—pretending AI can't do work it's clearly already doing. This denial doesn't help solve problems; it derails the discussion.

His attitude is pragmatic: he hates admitting the model can partially do better than him, but he can accept it. Because "I enjoy building things too much to have time to insist the old ways are better."

Implications for Developers

AI coding assistants are not a silver bullet; they require human oversight and ultimate responsibility. But for tasks like complex debugging, cross-file reasoning, and test generation, they can already significantly compress the time from problem to candidate patch. Refusing to acknowledge this might mean missing out on the time and joy you could regain.

For senior engineers, AI is not a replacement but takes over repetitive, context-switching-heavy labor, allowing focus on higher-value judgment and verification. For teams, this means task flow patterns may change—from long manual debugging cycles to faster human-AI collaborative iterations.

As the former Google engineer said: "I'm sick of the anti-AI rhetoric." Perhaps it's time to stop arguing about whether AI can and instead look at what it's already doing and learn to collaborate with it.

One-line Summary

A former Google engineer uses complex C++ debugging as an example to show how AI compresses days of work into an afternoon, urging a rational view of AI capabilities.

Paragraph Summary

A senior engineer with 15 years' experience, formerly at Google, posted on Reddit rebutting anti-AI rhetoric. Using tail latency debugging in a C++ search service as an example: previously it took days to manually trace RPC call chains, analyze traces and profiles, and build reproducers; now with AI assistants (like Opus), he can quickly locate deadline propagation issues across files, generate patches and tests, compressing the task to an afternoon. He emphasizes humans still need to be responsible for fixes and load testing, but AI can already significantly take over repetitive labor. The author believes denying what AI can already do doesn't help the discussion; the rational attitude is to accept that AI outperforms him on some tasks, freeing time to focus on higher-value judgment and the joy of building.