The Last Review

Maya Chen had been reviewing pull requests for eleven years. She could spot a race condition from the variable names alone. She knew which developers wrote defensive code and which ones assumed happy paths. She understood that a function called processUserData() with three nested loops probably meant someone had copy-pasted from Stack Overflow without understanding what they'd found.

This morning, December 19, 2025, she was reviewing her last PR before the migration.

The PR was from Derek, the senior backend engineer who'd been at the company since Series A. Derek wrote clean code. He commented his edge cases. He handled errors gracefully. His PRs were always a pleasure to review because you learned something from reading them.

Maya opened the diff. The changes added pagination to the user search endpoint. Standard stuff. Derek had written comprehensive unit tests covering the boundary cases - empty results, single results, exactly page-size results, page-size plus one.

She scanned the test file. All the tests would pass. She knew they would pass because Derek wrote tests that passed.

But there was something off about the cache invalidation logic.

Maya leaned closer to her monitor. The new pagination code checked a cache key before hitting the database. The cache key included page number and page size. But it didn't include the sort order. If a user searched for "engineering managers," sorted by experience descending, cached the results, then searched again sorted by experience ascending, they'd get the wrong page.

It was subtle. The kind of thing automated tests wouldn't catch because the tests didn't vary sort order across pagination calls. The kind of thing production monitoring wouldn't catch because the results would be valid - just wrong. The kind of thing users might not even notice unless they were paying close attention.

Maya started typing her review comment.

Then she stopped.

After today, this wouldn't be her job anymore. Starting Monday, the new AI testing system would handle code reviews. The system that could analyze every line of code in the repository, trace every execution path, identify every edge case, and generate tests faster than she could read them.

The system that didn't get tired. That didn't have biases about which developers wrote good code. That didn't miss things because it was thinking about its daughter's parent-teacher conference that afternoon.

The system that had already caught three critical security vulnerabilities in the authentication service that Maya and her team had completely missed.

She resumed typing.

The cache key needs to include sort order. Current implementation will return incorrect results if users change sort between queries.

Suggested fix:
- Line 47: Include sortBy and sortOrder in cache key
- Line 52: Add test case for sort order variation across cached requests

Maya submitted the comment and marked the PR as "changes requested."

Her phone buzzed. A Slack message from Derek: "oh shit you're right. thanks for catching that. will fix before EOD."

She smiled. Derek always responded immediately to review feedback. He never got defensive. He just fixed the problem and moved on.

She wondered if he'd be defensive with the AI system. Probably not. You couldn't really be defensive with a machine. It would find the bug, suggest the fix, and Derek would implement it. No ego involved. No relationship to manage. Just correct or incorrect.

More efficient that way.

Maya navigated to her next PR. This one was from Priya, a mid-level engineer who'd joined eight months ago. The changes refactored the notification service to use a message queue instead of synchronous calls.

It was a good refactor. The code was cleaner. The error handling was better. The tests were adequate.

But the migration path was wrong.

Priya had written a script to migrate existing notification records to the new queue-based schema. The script would work fine for the current production data. But it didn't account for notifications that were in the process of being sent when the migration ran. Those in-flight notifications would be lost.

The impact was minor - maybe a dozen users wouldn't get notifications during the fifteen-minute migration window. Priya probably figured that was acceptable.

But Maya had been here for eleven years. She remembered the incident three years ago when a similar migration had lost customer payment notifications. She remembered the CEO standing up in the all-hands meeting explaining to 400 employees that they'd lost $180,000 in revenue because twelve customers didn't receive payment reminder emails and their accounts went delinquent.

She remembered thinking: we should have caught that in review.

Maya started writing her comment explaining the in-flight notification problem and suggesting a two-phase migration approach. Then she stopped again.

Would the AI system know about that incident from three years ago? The postmortem was in the company wiki. Maybe the AI would read the wiki. Maybe it would correlate the current PR with historical incidents and flag the same risk.

Or maybe it wouldn't. Maybe it would analyze the code purely on its technical merits and approve the migration because, technically, the code worked correctly.

Maya finished her comment. She added a link to the three-year-old postmortem. She explained why the two-phase migration mattered even though it added complexity.

Priya replied fifteen minutes later: "wow I didn't know about that incident. you're absolutely right. I'll update the migration script."

Maya felt a small surge of satisfaction. That was the value of institutional knowledge. That was what eleven years at a company meant. You remembered the mistakes. You prevented them from happening again.

You couldn't train a model on that. You couldn't prompt engineer your way to remembering a specific incident from three years ago that wasn't in anyone's direct working memory but lived somewhere in the collective experience of the engineering organization.

Except the AI system probably could be trained on that. Feed it every postmortem. Every incident report. Every wiki page. Every Slack conversation. It would have perfect recall of every mistake the company had ever made.

Better recall than Maya had. Better than anyone had.

She opened her third PR of the morning. This one was from Carlos, who'd been promoted to tech lead six months ago. The changes added real-time websocket updates to the dashboard.

The code looked fine. The tests covered the main paths. But Maya noticed something in the error handling.

When the websocket connection failed, the code fell back to polling. Good design. But the polling interval was set to 500 milliseconds. For a dashboard that updated every five seconds, that meant ten times more traffic than necessary during any websocket outage.

Not a bug, exactly. Just wasteful. The kind of thing that would hurt at scale.

Maya wrote: "Consider increasing the polling fallback interval to match the websocket update frequency (5 seconds). Current 500ms interval will cause unnecessary load during outages."

Carlos responded: "good catch! I was worried about perceived latency but you're right, 5s makes more sense for this use case."

Maya stared at her response. "Good catch."

She'd heard that phrase thousands of times over eleven years. From junior engineers grateful she'd found their bugs. From senior engineers who'd made simple oversights. From tech leads who'd been thinking about architecture and missed implementation details.

Good catch. As if finding bugs was like catching a baseball. As if it required quick reflexes and sharp eyes.

But it wasn't like that. It was pattern recognition. It was experience. It was having reviewed enough websocket implementations to know what 500ms polling meant at scale.

The AI system would know that too. It would have reviewed millions of websocket implementations across every open source project on GitHub. It would know exactly what polling intervals made sense for different use cases.

It would catch everything Maya caught, and things she missed, and it would do it faster.

Maya opened her fourth PR. Then her fifth. Then her sixth. She reviewed seven more PRs before lunch. She found three bugs, suggested five optimizations, and approved four PRs that were genuinely perfect.

At 3 PM, she attended the team meeting where the engineering director announced the official transition schedule. Starting Monday, all code reviews would go through the AI system first. Human reviewers would only be escalated for novel architectural decisions or situations where the AI flagged uncertainty.

"This doesn't mean your reviews weren't valuable," the director said, making careful eye contact with Maya and the other QA engineers. "It just means we're evolving our process to leverage new capabilities."

Maya noticed he didn't say "your reviews are still valuable." Past tense. Weren't valuable. They used to be valuable. They're not anymore.

After the meeting, Derek messaged her privately: "pushed the cache fix you suggested. thanks again for catching that."

Then: "this sucks btw. I'm going to miss having you review my code."

Maya typed: "The AI will catch more bugs than I do."

Derek responded immediately: "probably yeah. but it won't know that I'm anxious about the holiday deploy and could use extra scrutiny on anything touching the payment service."

Maya stared at that message. Derek was right. She did know that. She knew Derek got nervous before holiday deploys because two years ago he'd pushed a bug right before Christmas break and spent three days of vacation debugging it with spotty internet at his in-laws' house.

She knew to pay extra attention to his payment service changes in December. She knew to flag anything that touched authentication during major conferences when the ops team was distracted. She knew which codebases were stable and which ones were held together with hope and technical debt.

The AI wouldn't know those things. Not without being explicitly told. And even if someone told it, would that really be the same as knowing?

Maya opened her last PR of the day. From her inbox, she had thirty-two more waiting. The AI system would handle them starting Monday. It would review them faster than she could. It would find bugs she would miss. It would suggest optimizations she wouldn't think of.

It would be better at her job than she was.

She took her time with the final PR. It was a small change from a junior engineer named Michael, who'd joined just three months ago. He was implementing user profile pictures. Simple feature. The code worked.

But Michael had stored the images directly in the database as base64-encoded strings. Maya knew from experience that would cause performance problems. The company had made that exact mistake five years ago with document attachments. They'd had to refactor the entire storage layer.

She wrote a detailed comment explaining why blob storage made more sense than database storage for images. She included links to the AWS S3 documentation. She suggested specific implementation approaches. She tried to write the kind of comment that would help Michael understand not just what to fix, but why.

Michael responded: "Thank you so much! I had no idea about the performance implications. This is exactly the kind of feedback I was hoping for."

Maya felt something twist in her chest. Michael was grateful. He'd learned something. He'd become a slightly better engineer because of her review.

The AI system would teach him too. It would probably teach him better. It would have more examples. More documentation. More patience for explaining basic concepts.

But would Michael feel the same gratitude? Would he message the AI system to say thank you?

Maya closed her laptop at 5:47 PM. She'd reviewed nineteen PRs on her last day. She'd found eleven bugs, suggested seventeen optimizations, and approved six perfectly written changes.

On Monday, the AI system would review forty PRs before lunch. It would find twenty-three bugs, suggest thirty-five optimizations, and approve twelve perfect changes.

It would be faster. More thorough. More consistent.

It would be better.

Maya rode the elevator down to the parking garage. Her badge - the one that said "Senior QA Engineer" - felt heavier than usual. On Monday, the title wouldn't matter. The AI didn't have a title. It didn't need one.

She sat in her car for a few minutes before starting the engine. Through the windshield, she could see the sixth floor windows where the engineering team worked. Lights were still on. Developers were still coding. Shipping features. Building products.

They'd still be doing that on Monday. The AI would just be reviewing their code.

More efficiently. More accurately. More completely.

Better.

Maya started her car and drove home. Tomorrow was Friday. She'd spend it transitioning her documentation. Explaining edge cases to the AI's training team. Making sure all her institutional knowledge got captured in the system.

Then Monday would come. The AI would start reviewing code. Derek would push PRs. Priya would submit refactorings. Carlos would add new features. Michael would implement profile pictures in blob storage instead of the database.

And Maya would... what? She'd been assigned to a new role. "Quality oversight." Reviewing the AI's reviews to make sure it wasn't making systematic errors. Escalation point for novel situations the AI couldn't handle.

It was a real job. It paid the same. It mattered.

But it wasn't code review.

Maya pulled into her driveway. Her daughter's bike was lying in the front yard where she'd left it that morning. Maya got out of the car, picked up the bike, and wheeled it into the garage.

Inside, her daughter was at the kitchen table doing homework. Math problems. Show your work, the instructions said.

"How was work?" her daughter asked, not looking up from her equations.

Maya thought about Derek's cache key bug. About Priya's migration script. About Carlos's polling interval. About Michael's image storage decision.

She thought about eleven years of catching things other people missed. Eleven years of knowing which questions to ask and which risks mattered and which developers needed which kind of feedback.

She thought about the AI system that would do all of that better than she ever could.

"It was fine," Maya said. "How was school?"

Her daughter shrugged. "Boring. We had to take this AI writing assessment. The teacher says they're going to use AI to grade our essays next semester."

"How do you feel about that?"

Her daughter looked up from her math. "I don't know. I guess it's good? Ms. Patterson says the AI gives better feedback than she can. More detailed. Catches more mistakes."

"Does that bother you?"

"Why would it bother me?"

Maya didn't have a good answer. She sat down across from her daughter and looked at the math homework. Show your work. Demonstrate the steps. Prove you understand the process, not just the answer.

But what happened when a calculator could do the process better than you? When it could show the work faster and more accurately and more completely?

What was the value of human work then?

"Need help with your homework?" Maya asked.

"No, I'm good," her daughter said. She was using a calculator. Of course she was. Everyone did. The math teacher didn't care as long as the students understood the concepts.

Maya wondered if future managers would care if their developers understood code review concepts, as long as the AI caught the bugs.

She stood up and started making dinner. Tomorrow was Friday. Monday was the new system. Wednesday was the holiday party where people would probably tell her she'd done great work and the AI was just making everyone more efficient.

And she'd smile and agree because what else could you say when you'd been replaced by something that was genuinely, measurably, undeniably better at your job than you were?

The meat sizzled in the pan. Her daughter solved another equation. Outside, the December sun was setting earlier each day.

Maya thought about Derek's message. "I'm going to miss having you review my code."

Past tense. Going to miss. Not missing yet. But by Monday, he would be.

And by Tuesday, he probably wouldn't.

The AI would catch the bug. Derek would fix it. The process would work smoothly. Nobody would miss the human reviewer who used to do that job.

Nobody except Maya, who'd spent eleven years learning how to do it well.

She flipped the meat and set the timer for five minutes.

Five minutes to go.

Friday, then Monday, then the rest of her career doing something other than the thing she'd learned to do best.

It was efficient. It was logical. It was better for the company.

It was the end of code review as a human profession.

The timer buzzed. Dinner was ready. Her daughter closed her math textbook. Outside, the December darkness settled over the neighborhood.

Inside, Maya served dinner and tried not to think about Monday.

She mostly succeeded.