# 15 years in software, ex-Google, and tired of the anti-AI rhetoric — retained record

> Retained reddit record from reddit:ClaudeAI.

Canonical: https://highsignal.app/data/records/0e9ee4d80c7afdbb

[← sources](https://highsignal.app/data)


source: [reddit](https://highsignal.app/data/reddit) (reddit:ClaudeAI)  published 2026-10-26 01:16 ingested 2026-10-27 02:36

[original source ↗](https://www.reddit.com/r/ClaudeAI/comments/1xfjhgh/15_years_in_software_exgoogle_and_tired_of_the/)

## retained text



```
I’ve spent 15 years in systems development including three at Google. I have plenty of complaints about AI but I hate how much of this conversation involves pretending it can’t do work that it’s already doing.  
Take something complicated like debugging tail latency in a C++ search serving system. Requests fan out through RPCs to multiple backends. Most finish quickly but a few slow responses hold everything up. Median latency looks fine while your p99 goes to shit. A change that passes every basic test can still fall apart under load.  
Here’s a nasty example. A slow RPC triggers a second request to another replica. The caller eventually times out but the backend work keeps running. Under load those extra requests start filling queues and making everything slower. Now the mechanism meant to reduce latency is adding to the overload.  
Fixing that means tracing deadlines through the call chain, checking cancellation and limiting the extra work. Then there’s the C++ lifetime problem. If a completion callback can still run after cancellation, freeing the request state too early can introduce a use-after-free. Congratulations, the latency fix now occasionally crashes the process.  
That’s the kind of task that could eat days in 2016. Reading unfamiliar code. Comparing traces. Digging through profiles. Building a reproducer because the existing tests never exercised that sequence. Going through another review because the patch fixed one path and broke another.  
I don’t miss handing something off and spending the next week explaining the same constraints across three revisions. I don’t miss dropping my own work for four hours because someone added retries without checking whether the operation was safe to repeat. Junior or senior, that shit is exhausting. I’ve caused those afternoons for other people too.  
Now I can give Opus the relevant implementation, traces and constraints and work through the problem immediately. Have it follow the request lifetime across files. Identify where the deadline stops being propagated. Propose a patch. Write tests that deliberately deliver callbacks after cancellation or simulate a slow backend. I can spend my attention checking its reasoning and testing the result.  
I’m still responsible for the fix. A production performance problem still needs load testing. But getting to a serious candidate patch is so much easier now that I have no interest in doing every step manually again. Plenty of tasks that used to bounce between people for weeks are things I can finish in an afternoon.  
Over the last year I’ve built things I’d been putting off for ages. I’m actually getting through ideas while I still care about them.  
I hate admitting that a model can do parts of my job better than me. I can live with it. I’m having too much fun building things to spend my time insisting the old way was better.
```



document fetched 2026-10-27 00:23 · canonical https://reddit.com/r/ClaudeAI/comments/1xfjhgh/15_years_in_software_exgoogle_and_tired_of_the
