---
title: 'Uncle Bob Stopped Reading AI-Generated Code'
source: 'https://youtube.com/watch?v=sClTAvkQDOU'
video_id: 'sClTAvkQDOU'
date: 2026-07-31
duration_sec: 501
---

# Uncle Bob Stopped Reading AI-Generated Code

> Source: [Uncle Bob Stopped Reading AI-Generated Code](https://youtube.com/watch?v=sClTAvkQDOU)

## Summary

This video unpacks Uncle Bob's viral tweet about not reading AI-generated code, exploring why the claim is controversial and what it means for software engineering. The host breaks down a risk-based framework for deciding when to review code, explains how to validate AI output without reading it, and shares his outlook on the future of developers.

### Key Points

- **Viral tweet from Uncle Bob** [00:01] — Robert C. Martin (Uncle Bob) went viral by claiming he no longer reads code written by his AI agents, sparking debate about the future of code review and AI-assisted development.
- **Uncle Bob's strategy** [00:15] — Uncle Bob says he started coding in the late '60s and his current strategy is to not read any agent-written code. Instead, he surrounds agents with extreme constraints: unit tests, Gherkin tests, QA procedures, quality metrics, mutation testing, and test coverage.
- **Core premise is controversial** [01:34] — The core premise is that developers should not read AI-generated code. The controversy stems largely from who said it, but the real question is whether the idea makes sense in the first place.
- **Risk spectrum for reading code** [02:03] — YouTuber Fio ranks code on a spectrum from a single-user web app to life-critical systems. The amount of code you should read depends on where your project falls: read everything for high-risk systems, skip most for low-risk ones.
- **Host's own risk context** [02:59] — The host runs Catabenche, a SaaS learning platform for .NET developers. Though mission-critical in parts, it has many users but nobody dies if AI-generated code is imperfect, placing it in the medium-to-low risk zone.
- **The 'AI slop' argument doesn't hold** [03:27] — The claim that all AI-generated code is slop is weakened by the fact that modern AI models are trained on human code. If AI output is slop, then human code is equally slop; more reasonably, some AI code is slop just like some human code is.
- **Verification replaces reading** [04:09] — Instead of reading code, you can validate it with manual QA, unit/integration/architecture tests, mutation testing, code coverage, custom debuggers, harnesses, and skills that instruct agents to verify their own output.
- **Use AI to validate AI** [05:54] — You can generate additional code that verifies your application code — more tests, QA scripts, and validation tools. This mirrors traditional software engineering, except humans used to generate the code being validated.
- **Code is just an artifact** [06:47] — Engineers often center their identity on writing code, but business value comes from functionality. If AI generates the code, the engineer's value shifts to verifying it and ensuring it delivers the intended function.
- **Future is bright for engineers** [07:52] — Even if agents generate most code, the host believes the future is bright for software engineers — especially those who focus on the engineering side: architecture, constraints, and quality gates.

### Conclusion

The video argues that reading AI-generated code is not inherently necessary when you have robust verification systems in place. As AI agents take on more coding, engineers should pivot from writing every line to designing the constraints and quality gates that ensure correctness.

## Transcript

very hot topic in the tech space and that is a viral tweet from Uncle Bob, the writer of Clean Code and Clean Architecture, where he claims that he is no longer reading his AI-generated code. Now, I want to unpack what's behind
this, where this makes sense, and I also want to share my approach to using agents and making sure that the code I produce works and also doing this efficiently. Here's the viral tweet from Uncle Bob, now racking up close to 3
million views, and I'm going to first just read through it. So, he says, "I'm significantly older than you." And this is actually a reply to the above use Cloud Code to help me write something, but I just don't feel
comfortable letting it edit my files. Does anybody else feel the same? If I'm understand it psychologically, if for no other reason. Started programming in 1983. Am I old?" So, to this, Uncle Bob replies, "I'm significantly older than
you. I started coding in the late '60s. My current strategy, and this is viral, is because he says, "His current strategy is to not read any of the code written by my agents. That's the only way I can take advantage of their
productivity. What I do instead is to surround the agents with extreme constraints, unit tests, Gherkin tests, QA procedures, quality metrics, mutation testing, test coverage, and a plethora of others. In the end, I have very high
because they've had to run the gauntlet of all of my constraints and tests. So, discuss, and I know this is going to is that this is where we are directionally going as software
isn't the future that they were hoping for. So, let's unpack this by writing out the core premise, which basically says that you should not be reading AI-generated code. The reason this ends up being so controversial is partly
because Uncle Bob said it. A lot of folks have pretty strong feelings for or reasons. Now, I'm not going to go into this. It's completely irrelevant for the discussion I want to have. And that is if this argument even makes sense to
begin with. Now, there's another popular YouTuber called Fio. He produced an excellent video discussing this, and he basically ranks all code on this spectrum, where at the lower end we've got, let's say, a web app with one user,
and on the high end we've got something like people die if the code is not how much of the code should you be reading depending on where you are on here, then you should definitely be reading all of your code regardless of
if it's human written or AI generated. Whereas, if you are somewhere here, then it probably doesn't even matter because if mistakes were made, the impacts are way, I don't intend to cannibalize his entire video. I'm going to actually
leave a link to it in the description below, and I encourage you to check it interesting points there. Now, where I would place my own code is somewhere on running a SaaS right now called Catabenche, which is a learning platform
for .NET developers. And although I consider the software mission-critical some parts of the platform, and I don't exactly have one user. I've actually got plenty of users, and the platform is growing daily. But still, nobody is
actually going to get hurt if the code in the platform is AI-generated and God forbid not read before being pushed to production. Now, how do you actually do this? How do you produce tons of code using AI without producing slop? So, the
against this is something along the lines of all AI-generated code is slop. Now, the reason I don't agree with this is because that all of the popular AI models that we are using right now were trained on human code. Go figure. So,
from this we could extrapolate that all human code is also slop, right? Because the AI doesn't really have an ability to produce new code. It only generates things it already saw and that were part of its training. So, I don't really
agree with this, but we can definitely say that some human-written code is slop and that might also imply that some AI-generated code is slop. How much that matters is again going to depend which type of application you are building.
Let's say that you are open-minded and that you actually want to explore this idea. How do you take AI-generated code, regardless of how it was produced, let's say cloud code or codex or any other agent that you could be using, how do
you take this code and validate that it is correct without having to actually read it? You have to do some sort of verification and fundamentally these are things that we've always done to make sure our code works correctly, right?
So, we've got things like manual QA. You open up the app, you test it and you validate that it works correctly. In fact, we've got a role called a QA engineer whose sole job is to validate that the code that you produce works
correctly or in other words, the application works as was intended when requirements were defined. Then another thing you can do is write tests and you can write a lot of this. So, we've got unit tests, we've got integration tests,
we've got architecture tests, which are really proving valuable with AI generating a lot of the code. It's now harder for the agents to break the architecture that you put in place because you can encode it behind a set
this, you can do a lot of interesting things. For example, you can have skills that tell the agent how to verify the code that it produces. You can build custom debuggers. You can add harnesses to ensure that whatever code you produce
works correctly. You can write tools to help you validate the functionality of your application. You can do mutation testing. You can also use code coverage. Although it's not a metric for code quality or correctness, it still helps
you measure how much of your application is actually covered by your tests and can focus your agents on to write more tests. Now, the really interesting thing is that, let's say you generate a given number of code measured in lines of
code, however many this is. What you now have the ability to do with AI and have the ability to do with AI and agents is generate a lot of additional code that validates the application code. So, basically, you write more code
to validate the application code that you generated, and this could be any outlined here. You can tell it to do manual QA. You can tell it to write more tests. You can generate skills that are going to verify that your code is
around the entire process of producing code that can help you verify the code as it's being generated. When you think about it, this is essentially how software engineering as an industry has functioned for many years, except
instead of using AI to generate code, we were using humans to generate the code, more or less the same. There were QA engineers, we would write tests ourselves to verify the code. And after all of that is said and done, humans
still produce slop. So, now the equation has shifted, and you as an engineer may no longer be responsible for writing, or let's say generating, the majority of the code in production code bases. And a lot of people have a problem with that
because they've centered their identity around writing code, where the code itself is only an artifact that gets you from point A to point B. I'm not saying that code isn't important, but from a business perspective, code is only one
combination of things, and essentially, whatever is the functionality that a given business provides that produces the actual value. Code is there to facilitate the value creation, and you
can still do the value creation part even without handwriting all of the code and using AI agents to produce the code. I'm going to wrap it up here, and I'd how you feel about all of this, and where you see our industry headed in the
coming years. And I promise to make a separate video discussing more in-depth we assume that agents are going to generate the majority of the code going forward. And that begs the question, what our role is going to be as
developers. And my overall opinion is that future is very bright if you are a software engineer, where I'm stressing the engineer part. If you want to see what my AI agent workflow looks like, I talked about it in-depth in this video
here, which you can take a look next. And then see how you could apply that to some side project that you're working on, or maybe even in your production this video, go ahead and smash the like
button. Thanks a lot for watching, and until next time, stay awesome.