u/japzlumine

I posted here recently asking whether understanding and reviewing code is mostly what software engineers do now, and got a lot of helpful responses pointing out things like:

1. Improving fundamentals by writing more code manually
2. Treating code review as a skill that develops with experience
3. Relying on things like tests, git history, and better system design

That made sense, so i'm trying to go one level deeper and understand what this actually looks like in practice for experienced engineers.

Most recently i ran into this on my own side project, an AI powered ads diagnostics tool. I had claude plan out a research/reasoning pipeline, the logic looked sound when i read it, but when i ran the actual tests the output quality was way off. Turns out the retry logic was hammering the same endpoint on failure, and the AI output fields weren't matching the schema a downstream dependency expected. I only caught it by running the tests and reading through the reasoning output manually, the plan looked completely fine on paper.

So my question is specifically, when you're reviewing a big PR in a real production codebase, what is your actual step by step process?

For example:

1. How do you decide what to look at first?
2. How do you quickly build enough context about the change?
3. How do you figure out blast radius / what might break?
4. How do you decide what matters vs what can be skimmed?
5. How do you catch the gap between "the logic looks right" and "this will actually behave correctly at runtime"?

I posted here recently asking whether understanding and reviewing code is mostly what software engineers do now, and got a lot of helpful responses pointing out things like:

1. Improving fundamentals by writing more code manually
2. Treating code review as a skill that develops with experience
3. Relying on things like tests, git history, and better system design

That made sense, so i'm trying to go one level deeper and understand what this actually looks like in practice for experienced engineers.

Most recently i ran into this on my own side project, an AI powered ads diagnostics tool. I had claude plan out a research/reasoning pipeline, the logic looked sound when i read it, but when i ran the actual tests the output quality was way off. Turns out the retry logic was hammering the same endpoint on failure, and the AI output fields weren't matching the schema a downstream dependency expected. I only caught it by running the tests and reading through the reasoning output manually, the plan looked completely fine on paper.

So my question is specifically, when you're reviewing a big PR in a real production codebase, what is your actual step by step process?

For example:

1. How do you decide what to look at first?
2. How do you quickly build enough context about the change?
3. How do you figure out blast radius / what might break?
4. How do you decide what matters vs what can be skimmed?
5. How do you catch the gap between "the logic looks right" and "this will actually behave correctly at runtime"?

I posted here recently asking whether understanding and reviewing code is mostly what software engineers do now, and got a lot of helpful responses pointing out things like:

1. Improving fundamentals by writing more code manually
2. Treating code review as a skill that develops with experience
3. Relying on things like tests, git history, and better system design

That made sense, so i'm trying to go one level deeper and understand what this actually looks like in practice for experienced engineers.

Most recently i ran into this on my own side project, an AI powered ads diagnostics tool. I had claude plan out a research/reasoning pipeline, the logic looked sound when i read it, but when i ran the actual tests the output quality was way off. Turns out the retry logic was hammering the same endpoint on failure, and the AI output fields weren't matching the schema a downstream dependency expected. I only caught it by running the tests and reading through the reasoning output manually, the plan looked completely fine on paper.

So my question is specifically, when you're reviewing a big PR in a real production codebase, what is your actual step by step process?

For example:

1. How do you decide what to look at first?
2. How do you quickly build enough context about the change?
3. How do you figure out blast radius / what might break?
4. How do you decide what matters vs what can be skimmed?
5. How do you catch the gap between "the logic looks right" and "this will actually behave correctly at runtime"?

I posted here recently asking whether understanding and reviewing code is mostly what software engineers do now, and got a lot of helpful responses pointing out things like:

1. Improving fundamentals by writing more code manually
2. Treating code review as a skill that develops with experience
3. Relying on things like tests, git history, and better system design

That made sense, so i'm trying to go one level deeper and understand what this actually looks like in practice for experienced engineers.

Most recently i ran into this on my own side project, an AI powered ads diagnostics tool. I had claude plan out a research/reasoning pipeline, the logic looked sound when i read it, but when i ran the actual tests the output quality was way off. Turns out the retry logic was hammering the same endpoint on failure, and the AI output fields weren't matching the schema a downstream dependency expected. I only caught it by running the tests and reading through the reasoning output manually, the plan looked completely fine on paper.

So my question is specifically, when you're reviewing a big PR in a real production codebase, what is your actual step by step process?

For example:

1. How do you decide what to look at first?
2. How do you quickly build enough context about the change?
3. How do you figure out blast radius / what might break?
4. How do you decide what matters vs what can be skimmed?
5. How do you catch the gap between "the logic looks right" and "this will actually behave correctly at runtime"?

I started coding about a year ago and have been using AI As a junior dev using AI coding tools, I feel like understanding and reviewing changes is harder than writing code, is this normal?coding tools heavily like cursor.

What I’m noticing is: Even when AI successfully generates working code, the hard part is no longer writing the code? But it’s understanding the code produced by AI and validating it quickly enough to ship with confidence.

Specifically, I often run into issues like:

1. Large or multiple file changes where it’s hard to understand the full impact
2. Unclear “blast radius” (what other parts of the system are affected)
3. Difficulty figuring out what actually matters in a diff vs what is noise
4. Spending more time debugging or reviewing AI output than generating it
5. Feeling like I need a better “mental model” or review system, but not sure what that would look like

I suspect part of this is just my inexperience, but I’m curious if this is also a real trend for more senior engineers:

1. Do staff/senior engineers feel this
   2 Do people build internal “review frameworks” or systems to handle AI-generated code?
2. Or is this just a normal part of software engineering that I’m overthinking?

I also wonder if the solution is:

1. Better prompting
2. Better testing/evals/harnesses
3. Or fundamentally changing how we review AI-generated code changes

Would be really interested in how experienced engineers think about this

I started coding about a year ago and have been using AI As a junior dev using AI coding tools, I feel like understanding and reviewing changes is harder than writing code, is this normal?coding tools heavily like cursor.

What I’m noticing is: Even when AI successfully generates working code, the hard part is no longer writing the code? But it’s understanding the code produced by AI and validating it quickly enough to ship with confidence.

Specifically, I often run into issues like:

1. Large or multiple file changes where it’s hard to understand the full impact
2. Unclear “blast radius” (what other parts of the system are affected)
3. Difficulty figuring out what actually matters in a diff vs what is noise
4. Spending more time debugging or reviewing AI output than generating it
5. Feeling like I need a better “mental model” or review system, but not sure what that would look like

I suspect part of this is just my inexperience, but I’m curious if this is also a real trend for more senior engineers:

1. Do staff/senior engineers feel this
   2 Do people build internal “review frameworks” or systems to handle AI-generated code?
2. Or is this just a normal part of software engineering that I’m overthinking?

I also wonder if the solution is:

1. Better prompting
2. Better testing/evals/harnesses
3. Or fundamentally changing how we review AI-generated code changes

Would be really interested in how experienced engineers think about this

I started coding about a year ago and have been using AI As a junior dev using AI coding tools, I feel like understanding and reviewing changes is harder than writing code, is this normal?coding tools heavily like cursor.

What I’m noticing is: Even when AI successfully generates working code, the hard part is no longer writing the code? But it’s understanding the code produced by AI and validating it quickly enough to ship with confidence.

Specifically, I often run into issues like:

1. Large or multiple file changes where it’s hard to understand the full impact
2. Unclear “blast radius” (what other parts of the system are affected)
3. Difficulty figuring out what actually matters in a diff vs what is noise
4. Spending more time debugging or reviewing AI output than generating it
5. Feeling like I need a better “mental model” or review system, but not sure what that would look like

I suspect part of this is just my inexperience, but I’m curious if this is also a real trend for more senior engineers:

1. Do staff/senior engineers feel this too, or does experience completely solve it?
   2 Do people build internal “review frameworks” or systems to handle AI-generated code?
2. Or is this just a normal part of software engineering that I’m overthinking?

I also wonder if the solution is:

1. Better prompting
2. Better testing/evals/harnesses
3. Or fundamentally changing how we review AI-generated code changes

Would be really interested in how experienced engineers think about this

I started coding about a year ago and have been using AI coding tools heavily like cursor.

What I’m noticing is: Even when AI successfully generates working code, the hard part is no longer writing the code? But it’s understanding the code produced by AI and validating it quickly enough to ship with confidence.

Specifically, I often run into issues like:

1. Large or multiple file changes where it’s hard to understand the full impact
2. Unclear “blast radius” (what other parts of the system are affected)
3. Difficulty figuring out what actually matters in a diff vs what is noise
4. Spending more time debugging or reviewing AI output than generating it
5. Feeling like I need a better “mental model” or review system, but not sure what that would look like

I suspect part of this is just my inexperience, but I’m curious if this is also a real trend for more senior engineers:

1. Do staff/senior engineers feel this too, or does experience completely solve it?
   2 Do people build internal “review frameworks” or systems to handle AI-generated code?
2. Or is this just a normal part of software engineering that I’m overthinking?

I also wonder if the solution is:

1. Better prompting
2. Better testing/evals/harnesses
3. Or fundamentally changing how we review AI-generated code changes

Would be really interested in how experienced engineers think about this

I started coding about a year ago and have been using AI coding tools heavily like cursor.

What I’m noticing is: Even when AI successfully generates working code, the hard part is no longer writing the code? But it’s understanding the code produced by AI and validating it quickly enough to ship with confidence.

Specifically, I often run into issues like:

1. Large or multiple file changes where it's hard to understand the full impact
2. Unclear "blast radius" (what other parts of the system are affected)
3. Difficulty figuring out what actually matters in a diff vs what is noise
4. Spending more time debugging or reviewing Al output than generating it
5. Feeling like I need a better "mental model" or review system, but not sure what that would look like

I suspect part of this is just my inexperience, but I'm curious if this is also a real trend for more senior engineers:

1. Do staff/senior engineers feel this too, or does experience completely solve it?
   2 Do people build internal "review frameworks" or systems to handle Al-generated code?
2. Or is this just a normal part of software engineering that I'm overthinking?

I also wonder if the solution is:

1. Better prompting
2. Better testing/evals/harnesses
3. Or fundamentally changing how we review Al-generated code changes

Would be really interested in how experienced engineers think about this

I started coding about a year ago and have been using AI coding tools heavily like cursor.

What I’m noticing is: Even when AI successfully generates working code, the hard part is no longer writing the code? But it’s understanding the code produced by AI and validating it quickly enough to ship with confidence.

Specifically, I often run into issues like:

1. Large or multiple file changes where it’s hard to understand the full impact
2. Unclear “blast radius” (what other parts of the system are affected)
3. Difficulty figuring out what actually matters in a diff vs what is noise
4. Spending more time debugging or reviewing AI output than generating it
5. Feeling like I need a better “mental model” or review system, but not sure what that would look like

I suspect part of this is just my inexperience, but I’m curious if this is also a real trend for more senior engineers:

1. Do staff/senior engineers feel this too, or does experience completely solve it?
   2 Do people build internal “review frameworks” or systems to handle AI-generated code?
2. Or is this just a normal part of software engineering that I’m overthinking?

I also wonder if the solution is:

1. Better prompting
2. Better testing/evals/harnesses
3. Or fundamentally changing how we review AI-generated code changes

Would be really interested in how experienced engineers think about this

I started coding about a year ago and have been using AI coding tools heavily like cursor.

What I’m noticing is: Even when AI successfully generates working code, the hard part is no longer writing the code? But it’s understanding the code produced by AI and validating it quickly enough to ship with confidence.

Specifically, I often run into issues like:

1. Large or multiple file changes where it’s hard to understand the full impact
2. Unclear “blast radius” (what other parts of the system are affected)
3. Difficulty figuring out what actually matters in a diff vs what is noise
4. Spending more time debugging or reviewing AI output than generating it
5. Feeling like I need a better “mental model” or review system, but not sure what that would look like

I suspect part of this is just my inexperience, but I’m curious if this is also a real trend for more senior engineers:

1. Do staff/senior engineers feel this too, or does experience completely solve it?
   2 Do people build internal “review frameworks” or systems to handle AI-generated code?
2. Or is this just a normal part of software engineering that I’m overthinking?

I also wonder if the solution is:

1. better prompting
2. better testing/evals/harnesses
3. or fundamentally changing how we review AI-generated code changes

Would be really interested in how experienced engineers think about this

I started coding about a year ago and have been using AI coding tools heavily like cursor.

What I’m noticing is: Even when AI successfully generates working code, the hard part is no longer writing the code? But it’s understanding the code produced by AI and validating it quickly enough to ship with confidence.

Specifically, I often run into issues like:

1. Large or multiple file changes where it’s hard to understand the full impact
2. Unclear “blast radius” (what other parts of the system are affected)
3. Difficulty figuring out what actually matters in a diff vs what is noise
4. Spending more time debugging or reviewing AI output than generating it
5. Feeling like I need a better “mental model” or review system, but not sure what that would look like

I suspect part of this is just my inexperience, but I’m curious if this is also a real trend for more senior engineers:

1. Do staff/senior engineers feel this too, or does experience completely solve it?
   2 Do people build internal “review frameworks” or systems to handle AI-generated code?
2. Or is this just a normal part of software engineering that I’m overthinking?

I also wonder if the solution is:

1. Better prompting
2. Better testing/evals/harnesses
3. Or fundamentally changing how we review AI-generated code changes

Would be really interested in how experienced engineers think about this