u/Downtown-Function-10

I caught myself asking claude how to write a debounce function last week, a DEBOUNCE function, I've written that thing from scratch probably 30 times since like 2015

so im 11 years in. Six months ago reviewing was maybe a fifth of my day, now it's most of it. The juniors prompt their way through features with Cursor or Claude Code, coderabbit does the first pass so the nitpicky stuff is gone before I even open the PR, and I just sit there all day checking architecture and business logic like some kind of code customs officer.

And the weird thing is I'm genuinely better at reviewing now. I catch stuff across PRs I never used to, two people quietly building the same helper in different corners of the repo, a refactor that changes behavior nobody asked it to change. That's a real skill and it's sharper than ever.

But the writing muscle is going and I can feel it going. I sat down to build a small thing for myself last weekend, no deadline, nobody waiting on it, and I kept reaching for the agent to scaffold it. I forced myself to do it by hand and it was slow and clumsy and kind of embarrassing (not fishing for "just practice more lol" btw, I know)

I know the job is shipping working software and not suffering for the craft. Still feels like losing something

anyone else deep in review mode and noticing this

We started with 8 agentic workflow design patterns six months ago. Four survived. The other four fell apart in ways that took a while to understand

The survivors. Agent-as-first-reviewer, where the agent reviews before the human and catches the mechanical stuff so the human focuses on design. We run coderabbit on every PR and a human does a focused pass on architecture after. Generate-then-curate, where the agent generates a large set of outputs and the human keeps the good ones

well it Works because generating is cheap and curating is easier than writing from scratch. Bounded autonomy, where the agent operates freely within strict boundaries, only certain files, only certain commands, can't deploy. Escalation, where the agent tries and if confidence is low it escalates to a human instead of guessing

The ones that died. Fully autonomous loops without checkpoints, they spiral and burn money. Multi-agent chains where agents hand off to each other, error propagation was brutal, one wrong call reinforced through three agents. Agent-driven prioritization, no understanding of business context or politics

The meta-lesson after six months. The patterns that survived all have a human in the loop at the judgment points and agent autonomy at the mechanical points. Claude Code and Cursor handle the writing, coderabbit handles the first review pass, humans handle the calls. That split is what makes agentic workflow automation actually stick

We have 7 devs and 2 seniors. Before this year, every meaningful PR review went through one of those two people. The backlog would hit 12-15 open PRs regularly and juniors would rubber-stamp each other's work just to keep things moving.

About 5 months ago we started running coderabbit on every PR as an automated first-pass reviewer. It runs within minutes, leaves inline comments on style issues, missing error handling, security patterns, unused imports. By the time a senior opens the PR the surface-level stuff is already flagged and usually fixed. we use bugbot, and claude for same process as well.

The thing I didn't expect was what it did to human reviews. Our seniors stopped spending 20 minutes on formatting and started jumping straight to architecture. Reviews got shorter but the actual quality of feedback went up because they're thinking about whether the approach makes sense instead of pointing out a missing null check for the tenth time.

The other thing i believe people ignore is what agentic ai code review does for juniors. When a senior leaves a comment they rarely explain why because they're busy. The automated reviewer actually explains the reasoning behind each flag. I've watched our juniors improve faster in the last few months than they did the year before that.

by no means its not perfect, it flags stuff that isn't a real issue sometimes and architectural decisions obviously still need a human. But our review backlog sits at 3-4 PRs now instead of 15

One year, 5 devs, three different coding agents. Here's what actually stuck and what we dropped.

Never let agents access secrets or deploy anything. Non-negotiable. We learned this one early when an agent tried to helpfully "fix" an environment config it found while searching for context. Set up automated first-pass review on every PR. We use bugbot, coderabbit, claude.md for this and it catches stuff humans miss because they're already tired of reviewing by the third PR of the day. Break tasks into small scoped units. Agents are great at "add this endpoint with these requirements" and terrible at "improve the architecture."

Things we THOUGHT were best practices but dropped: forcing agents to explain every change before making it. Slowed everything down and the explanations were often wrong anyway. Requiring human approval at every loop iteration, which killed the entire speed benefit. And trying to use one agent for everything when different tools are better at different things.

The biggest one honestly is just reviewing agent output as carefully as you'd review a junior's code. The temptation to rubber-stamp it because it looks clean is real and it's how bugs ship. Our rule is if you wouldn't merge a human's PR after a 2-minute glance, don't do it for an agent's either