# How I Review AI Code - (Meta Senior Staff Engineer)
Canonical: https://social-archive.org/tommypkm/TcdXKnwXRs
Original URL: https://www.youtube.com/watch?v=b2QkhmQ0sT0
Author: John Kim
Platform: youtube
Share mode: full
## Content
AI can write more code than any engineer can manually review. Here is the risk-based workflow I use to review AI generated code. Chapters: 00:00 Should you still read AI-generated code? 01:30 The AI or Not demo 02:34 Code review is a gradient 03:47 Codebase trees and blast radius 05:05 Build behind feature gates 06:31 Require proof in every PR 09:00 Leaf code vs. trunk code 10:20 Safety over stylistic nits 12:31 Independent agent reviews 14:05 Codex on GitHub and PR babysitting 16:20 Merge-ready is not launch-ready 17:52 Experiments, canaries, and rollback 19:32 My current answer 20:04 Knowing the codebase still matters Get the PushToProd newsletter: https://getpushtoprod.substack.com Related Videos Codex: https://youtu.be/nQFtsehu7h0?si=Ty1GD80ybTuQTlJk ClaudeCode: https://youtu.be/mZzhfPle9QU?si=Oxf794c9gfd3-923 More from Premium Goblin: Instagram: https://www.instagram.com/premiumgoblin TikTok: https://www.tiktok.com/@premiumgoblin Threads: https://www.threads.com/@premiumgoblin X: https://x.com/PremiumGoblin Bluesky: https://bsky.app/profile/premiumgoblin.bsky.social LinkedIn: https://www.linkedin.com/in/jonnykvids #AI #CodeReview #SoftwareEngineering --- ## Transcript [0:00](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=0s) Well, hello there. [0:01](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1s) So are you even reading your code these [0:03](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=3s) days? [0:04](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=4s) Or do you just send it off and just let [0:06](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=6s) your vibe code it, AI slop code, just into [0:09](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=9s) the wild without any review? [0:10](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=10s) Or are you still on the camp of reading [0:12](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=12s) all your code? [0:13](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=13s) In my opinion, this topic of code review [0:16](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=16s) is very split right now. [0:17](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=17s) The community is very split. [0:20](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=20s) There's a group of people who said, if [0:22](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=22s) you're reviewing your code still, then [0:23](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=23s) you're not moving fast enough. [0:25](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=25s) The agents are probably already better at [0:27](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=27s) reviewing code than you are. [0:29](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=29s) So why are you reading your code? [0:31](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=31s) Those are the that camp. [0:32](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=32s) The other camp is people who are saying, [0:34](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=34s) no, the AI agents are still not great yet. [0:36](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=36s) It's not perfect, it makes dumb mistakes [0:38](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=38s) and you're creating a lot of AI slop and [0:40](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=40s) you really need to tone it down and review [0:43](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=43s) the stuff that you're writing. [0:44](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=44s) So there's these two camps. [0:46](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=46s) And in this video, we're gonna talk about [0:48](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=48s) what I think of this topic. [0:50](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=50s) And I'm also going to give you my [0:51](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=51s) strategies on how I navigate and review my [0:55](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=55s) own code and land high quality code into [0:57](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=57s) the production. [0:58](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=58s) So yeah, that's what we'll cover in this [1:00](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=60s) video today. [1:01](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=61s) So if you're new to this channel, my name [1:02](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=62s) is John. [1:03](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=63s) I'm a senior staff software engineer at [1:05](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=65s) Meta. [1:05](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=65s) And on this channel, I talk about AI tech [1:08](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=68s) news, AI tech tutorials, anything to do [1:11](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=71s) with AI. [1:12](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=72s) It's my fun side hobby to dig into all of [1:14](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=74s) this. [1:15](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=75s) But yeah, a lot of you guys are not [1:16](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=76s) subscribed. [1:16](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=76s) You guys watch a lot of my videos, but for [1:18](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=78s) some reason, don't subscribe. [1:20](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=80s) So do a brother a favor and subscribe. [1:23](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=83s) I get a ton of tokens if people subscribe. [1:26](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=86s) I don't actually, but please subscribe. [1:29](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=89s) So let's get right into this video. [1:30](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=90s) So as usual, I made some slides, just some [1:32](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=92s) simple slides to have some talking points [1:35](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=95s) over all of this. [1:36](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=96s) And for this video, I also created just a [1:39](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=99s) simple website that like you can swipe [1:41](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=101s) essentially to vote whether something is [1:44](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=104s) AI or Not. [1:45](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=105s) And they will tell you like if it's AI or [1:47](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=107s) not. [1:48](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=108s) It's just a simple demo app and it's [1:50](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=110s) really there so I could showcase some of [1:52](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=112s) the tools and like things that I'm [1:54](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=114s) thinking about for the video. [1:56](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=116s) So let's start off with the obvious. [1:58](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=118s) I think we can all safely say with the [2:01](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=121s) advent of AI coding, the amount of code [2:03](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=123s) that people are generating is going [2:05](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=125s) through the roof. [2:06](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=126s) It's like so much more code. [2:09](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=129s) People are writing a lot more features. [2:11](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=131s) They're writing more tests. [2:12](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=132s) They're just doing a lot more because one [2:15](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=135s) person can split up multiple agents and [2:17](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=137s) generate a ton of code. [2:18](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=138s) And to be honest, it's almost impossible [2:22](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=142s) of a task for a single engineer to review [2:24](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=144s) even their own code, let alone do code [2:27](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=147s) reviews for other people. [2:28](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=148s) So where do I stand right now personally [2:31](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=151s) for code reviews? [2:32](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=152s) And the answer is, it depends. [2:35](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=155s) I think like any good answer to any hard [2:38](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=158s) problem, answer is really, it depends [2:41](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=161s) because the reality of code reviews is a [2:43](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=163s) gradient. [2:44](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=164s) It really depends on the code that you're [2:46](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=166s) reviewing. [2:47](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=167s) So when you're writing code and when [2:49](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=169s) you're building a feature, the AI agents [2:51](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=171s) should be part of the entire code's [2:54](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=174s) journey to production from planning, [2:57](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=177s) building, reviewing, and launching. [2:59](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=179s) Every single part of this, you should [3:01](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=181s) actually include your AI agents throughout [3:04](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=184s) the whole process, right? [3:05](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=185s) Whether it's planning out a spec to build [3:08](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=188s) out, making sure things are feature [3:09](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=189s) complete and making sure you have like [3:11](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=191s) evaluations and like validation criterias [3:13](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=193s) that you're thinking about ahead of time. [3:15](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=195s) And when you're building the code, you [3:17](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=197s) wanna have agentic validation so that the [3:19](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=199s) AI can self validate and self fix itself [3:22](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=202s) and then get the code right a lot more [3:25](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=205s) often. [3:25](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=205s) And then we have the review, which is like [3:27](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=207s) what we're talking about today. [3:29](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=209s) And we're gonna talk about some strategies [3:31](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=211s) on how you should do this. [3:32](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=212s) And then when you're launching, I think [3:34](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=214s) this also should be part of it. [3:36](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=216s) You wanna feature gate and run experiments [3:38](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=218s) on your code. [3:39](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=219s) And all of these things I think tie [3:41](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=221s) together to answer the question, when and [3:44](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=224s) how much should you review a code? [3:46](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=226s) So it really depends, right? [3:48](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=228s) Now, the big concept that I wanna let you [3:50](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=230s) guys know about today is that I think of [3:52](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=232s) the code base like a tree. [3:55](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=235s) And like a tree, there are different parts [3:58](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=238s) of the tree that is more important. [3:59](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=239s) So think of like kind of the trunk, the [4:02](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=242s) root, the main part of the code, that's [4:05](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=245s) like your main entry points, like your [4:07](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=247s) App.js that has all of the different [4:09](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=249s) helpers that are like added to it. [4:11](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=251s) And then your infrastructure code, like [4:13](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=253s) image processing, networking, and all [4:15](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=255s) these things that if something goes wrong [4:18](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=258s) in that code base, it can affect the [4:20](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=260s) entire app. [4:20](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=260s) I think of that as like a trunk piece of [4:22](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=262s) code. [4:22](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=262s) And then there's like leaf nodes. [4:24](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=264s) And we're gonna get into more of this [4:25](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=265s) topic throughout this video, but start [4:27](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=267s) thinking about your code base as a trunk. [4:29](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=269s) And as soon as you start thinking about [4:31](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=271s) this, then the obvious next thing that you [4:33](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=273s) naturally think about is that the review [4:35](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=275s) depth, the depth that your own effort [4:38](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=278s) level on reviewing a certain code, it [4:40](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=280s) should really be based on like the blast [4:43](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=283s) radius of that code change. [4:45](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=285s) As an example, if you're touching [4:46](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=286s) something that's like core image rendering [4:48](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=288s) infrastructure that touches all the [4:50](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=290s) different image renderings, and there's a [4:52](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=292s) lot of downstream dependencies, then I [4:54](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=294s) would spend a lot of time reading that [4:55](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=295s) piece of code, for example. [4:57](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=297s) And then for any like one off leaf node [5:00](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=300s) code, you could probably just have agents [5:02](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=302s) do simple validations like component [5:04](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=304s) testing or snapshot testing and just [5:07](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=307s) visually validate the PR as long as they [5:10](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=310s) have proof in the PR. [5:11](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=311s) So this concept of like changing your [5:13](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=313s) effort level, depending on the importance [5:16](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=316s) of the code, I think really matters a lot. [5:18](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=318s) And you should actually do this planning [5:19](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=319s) from the beginning. [5:20](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=320s) So when you're planning the entire [5:22](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=322s) feature, you actually want to feature gate [5:24](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=324s) it. [5:25](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=325s) Now, if you don't know what feature gating [5:26](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=326s) is, it's essentially adding a branching [5:29](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=329s) logic in your code base where you can say, [5:32](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=332s) hey, this feature is on or off. [5:34](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=334s) So there's a concept called feature [5:36](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=336s) toggling, a really popular option is [5:38](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=338s) called LaunchDarkly, and you could have [5:40](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=340s) feature gating. [5:41](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=341s) There's a lot of actually infrastructure [5:42](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=342s) that you need to do feature gating [5:44](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=344s) properly, but you can start out really [5:46](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=346s) simple by just adding a Boolean flag in [5:48](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=348s) your code base. [5:49](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=349s) It's a gating code and you just turn [5:51](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=351s) things on and off. [5:52](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=352s) So from the beginning, if you're planning [5:54](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=354s) a new feature, think in broad strokes and [5:57](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=357s) gate all of the things out, and then think [5:59](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=359s) a lot about the integration pieces. [6:01](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=361s) So you want to separate out leaf nodes, [6:04](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=364s) things that doesn't touch any of the [6:06](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=366s) existing code bases, and then you want to [6:08](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=368s) think about integration separately. [6:09](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=369s) You really want to like gate those [6:11](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=371s) integration layers. [6:12](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=372s) So once you have like a good solid plan [6:14](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=374s) and a good like roadmap, and you have like [6:16](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=376s) good feature gating, like ready to go, [6:18](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=378s) then you can start coding. [6:19](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=379s) And then this coding part is like, you [6:21](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=381s) know, just use agents to build a code out, [6:24](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=384s) and then you can just use the agents to [6:25](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=385s) like, you know, make atomic changes. [6:27](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=387s) I have a ton of videos around using agents [6:30](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=390s) to code, but you know, we're not covering [6:32](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=392s) that particular topic, but once you're [6:34](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=394s) ready for a PR, what should go in that PR? [6:37](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=397s) So let's think about that. [6:38](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=398s) So in my opinion, for your diffs to be [6:40](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=400s) really like solid, your PRs to be like [6:42](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=402s) rock solid, you really want to anchor and [6:45](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=405s) push your agents to give you proof. [6:47](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=407s) And there's many different types of proof [6:49](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=409s) that the agents could give you. [6:50](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=410s) There can be just straight up unit tests. [6:53](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=413s) So as an example, something like this, [6:55](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=415s) it's just a straight up unit test, very [6:57](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=417s) simple, a lot of tests. [6:59](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=419s) And this is like just reading the test [7:01](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=421s) names and just skimming the tests and the [7:03](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=423s) asserts. [7:04](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=424s) You could quickly get some like good sense [7:06](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=426s) of, oh, there's like good logic testing [7:08](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=428s) that's happening. [7:09](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=429s) One side note is you want to be careful [7:11](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=431s) here when the agents are writing tests. [7:13](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=433s) You should probably make your own skill [7:14](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=434s) around not writing useless tests. [7:18](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=438s) That's like a little side tip. [7:19](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=439s) And then you also want runtime evidence. [7:21](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=441s) So let's say that you have a lot of like [7:24](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=444s) runtime logs. [7:25](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=445s) And I talk about this in my agentic [7:26](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=446s) engineering video, where you want to [7:28](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=448s) really anchor on giving more visibility [7:31](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=451s) and more eyes for the agents. [7:33](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=453s) So you can have runtime evidence and then [7:35](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=455s) you could have visual evidence where maybe [7:37](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=457s) it's a screenshot. [7:38](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=458s) And then I also ask the agents to give a [7:41](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=461s) confidence level on their code and their [7:44](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=464s) gating and like different parts of the [7:46](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=466s) code. [7:46](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=466s) So you really want to push your agents [7:48](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=468s) when you're ready to like push out a PR on [7:50](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=470s) these kinds of things. [7:51](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=471s) It's like, do you have evidence? [7:52](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=472s) Obviously you want to build these into [7:54](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=474s) your skills. [7:54](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=474s) So let's take a look at like UI proof, [7:57](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=477s) right? [7:57](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=477s) So one of the things I like to do every [7:59](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=479s) time I make changes with the AI, I always [8:02](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=482s) ask it to have a video or a UI screenshot, [8:05](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=485s) right? [8:06](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=486s) So for this one, this lets the player save [8:09](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=489s) a card, right? [8:10](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=490s) So you can see right here, there is a save [8:13](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=493s) button. [8:14](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=494s) So I can see that, oh, okay, this was [8:15](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=495s) saved. [8:15](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=495s) And here's some like simple code changes. [8:17](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=497s) And then it looks roughly right. [8:19](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=499s) But the point is I see a visual proof. [8:22](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=502s) So immediately I'm a lot more believing of [8:25](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=505s) this AI's code output, right? [8:27](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=507s) So if you have the visual proof and if you [8:29](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=509s) know that it's safe, then it's a lot safe [8:31](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=511s) to land. [8:32](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=512s) So having proof and having more proof lets [8:35](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=515s) you move faster because you don't have to [8:37](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=517s) manually check these proofs. [8:38](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=518s) And this is really around agentic [8:40](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=520s) validation. [8:41](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=521s) And I talk about that in my agentic [8:43](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=523s) engineering video, but agentic validation [8:46](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=526s) is a core concept of being able to read [8:49](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=529s) less code. [8:49](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=529s) Because if you have a lot of these proof [8:52](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=532s) upfront on the PR, then you don't have to [8:54](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=534s) read as much code. [8:55](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=535s) Now the next big concept, and this is kind [8:58](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=538s) of in the tree concept is leaf code. [9:00](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=540s) A leaf code is really code that is written [9:03](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=543s) in isolation or it's completely gated off [9:06](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=546s) in a feature gate. [9:07](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=547s) So this can be like one off components [9:10](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=550s) that you can just validate with like a [9:12](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=552s) component test or a snapshot test, right? [9:15](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=555s) Or maybe it's new infrastructure, new [9:18](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=558s) logic, maybe a new endpoint that you're [9:20](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=560s) integrating with. [9:21](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=561s) And you could just validate that with unit [9:23](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=563s) tests or integration tests. [9:25](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=565s) And as long as they're not integrated to [9:27](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=567s) the main production code base, you can [9:29](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=569s) move really quickly. [9:30](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=570s) And then I'll cover later what you should [9:32](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=572s) be doing. [9:33](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=573s) So for me, when I'm reviewing leaf like [9:36](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=576s) code, I spend a lot less time. [9:37](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=577s) I'm almost just mainly skimming the code [9:40](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=580s) and making sure things are not like very [9:42](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=582s) off or like something is just obviously [9:44](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=584s) wrong. [9:45](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=585s) And for example, what can be a trunk is [9:47](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=587s) like, you know, in the reducer. [9:48](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=588s) Reducer has a lot of shared state. [9:50](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=590s) So let's say you change some behavior here [9:53](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=593s) in this like game action advanced cards. [9:55](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=595s) Maybe there's like a new card type or [9:56](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=596s) something like that. [9:57](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=597s) And you're changing existing behavior. [9:59](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=599s) And if that behavior is not gated out, [10:02](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=602s) then I will spend a lot more time [10:03](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=603s) reviewing it because that changes [10:04](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=604s) production, right? [10:05](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=605s) And then this has trickle down effects and [10:07](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=607s) side effects and all these things can [10:09](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=609s) really matter and affect production code, [10:11](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=611s) right? [10:11](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=611s) So you're really anchoring on safety. [10:13](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=613s) So we kind of covered like thinking about [10:15](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=615s) code as like this gradient and how you [10:18](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=618s) should anchor on changing your effort [10:21](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=621s) level, right? [10:22](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=622s) And in my opinion, everything should be [10:25](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=625s) anchored on safety. [10:26](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=626s) What is the control experience that should [10:28](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=628s) not change? [10:29](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=629s) And if this change went wrong, how bad can [10:32](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=632s) it be? [10:33](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=633s) And then can I roll this change back? [10:36](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=636s) And then that really just depends on [10:37](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=637s) feature gating, right? [10:38](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=638s) So if you can answer these questions, [10:40](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=640s) especially the last one, then you can [10:43](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=643s) spend a lot less time reviewing each [10:45](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=645s) individual code. [10:46](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=646s) Now, one other thing that is like not that [10:48](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=648s) important in my opinion these days that is [10:50](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=650s) part of like usually reviews is like nits [10:54](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=654s) and like little like different ways of [10:56](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=656s) writing. [10:57](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=657s) And I would just leverage like static [10:58](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=658s) checking here to be able to do a lot of [11:00](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=660s) that work. [11:01](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=661s) So like type checking, linting, and all [11:04](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=664s) those kinds of things. [11:05](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=665s) And agents are really good at doing stuff [11:07](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=667s) like this. [11:08](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=668s) So we have a Codex reviewer here and it's [11:10](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=670s) like seeing some linting issues. [11:12](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=672s) So it's like saying we should fix it as an [11:14](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=674s) example. [11:15](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=675s) And here's some like stylistic changes, [11:17](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=677s) right? [11:18](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=678s) So one big thing about code review is that [11:20](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=680s) I think the old days of like having your [11:23](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=683s) nits and then like, oh, the code should [11:25](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=685s) look this way. [11:26](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=686s) This is my favorite way of writing code. [11:29](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=689s) I think that's kind of dead. [11:30](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=690s) I think we write so much code and code is [11:32](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=692s) being a lot more fluid and refactors are [11:35](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=695s) happening a lot more often. [11:36](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=696s) And it's a lot easier to do, especially [11:39](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=699s) once like there's good validations for the [11:40](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=700s) code that you wanna refactor. [11:42](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=702s) I think these kinds of nits don't really [11:44](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=704s) belong in the conversation of code reviews [11:46](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=706s) anymore. [11:47](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=707s) So going back to the original question is, [11:50](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=710s) do I read the code? [11:51](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=711s) The simple answer is yes, I still read a [11:53](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=713s) lot of code. [11:54](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=714s) I think I read more code than I did [11:57](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=717s) before, but I definitely have this like [12:00](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=720s) knob where I first asked myself, is this a [12:03](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=723s) core change, like a trunk change? [12:05](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=725s) And is it like an infra? [12:07](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=727s) Does it have a lot of like dependencies? [12:09](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=729s) If so, I increase it. [12:11](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=731s) And then I say, is this safe? [12:12](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=732s) Is there gating? [12:13](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=733s) If something went wrong, like what can [12:15](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=735s) happen? [12:15](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=735s) So all of these things really change how [12:17](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=737s) much I review the code, right? [12:19](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=739s) And then the more dangerous it is, the [12:21](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=741s) more I spend time. [12:22](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=742s) More of that changes a one-way door, I [12:24](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=744s) spend more time reviewing, right? [12:26](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=746s) Now let's get kind of to the fun parts of [12:28](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=748s) like looking at how you can use agents to [12:30](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=750s) kind of help you review your code. [12:32](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=752s) Now, in my opinion, AI is really good at [12:34](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=754s) reviewing code already. [12:36](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=756s) I actually do think it's better than most [12:39](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=759s) humans. [12:39](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=759s) The issue is a lot of people are doing it [12:42](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=762s) wrong. [12:42](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=762s) And in my opinion, there's a few things [12:45](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=765s) that you should really anchor on doing. [12:46](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=766s) One, you should have a really good review [12:48](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=768s) skill. [12:49](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=769s) I think both Claude Code and Codex have [12:51](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=771s) really good built reviews. [12:53](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=773s) And then here is the review agent right [12:56](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=776s) here. [12:56](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=776s) And then for Claude Code, it's slash code [13:00](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=780s) review. [13:01](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=781s) So these are all both really good review [13:03](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=783s) agents in my opinion. [13:05](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=785s) But one thing that's kind of important to [13:06](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=786s) do is to use a new sub-agent or a [13:09](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=789s) different agent, an agent that doesn't [13:11](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=791s) have the context of the code that it was [13:13](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=793s) used to create the code. [13:15](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=795s) Because the agents will cheat. [13:17](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=797s) You know, all the context that you gave [13:18](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=798s) it, it will cheat. [13:20](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=800s) And they will really try to anchor on like [13:22](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=802s) a lot of the previous conversation. [13:24](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=804s) So you really want to review the code with [13:27](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=807s) like a different sub-agent or like a [13:29](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=809s) separate agent that is called an [13:31](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=811s) adversarial review agent. [13:33](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=813s) And when you have an agent write a diff or [13:35](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=815s) thing, just have like a good template that [13:37](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=817s) the agent can pull from. [13:38](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=818s) So your PRs look the same, they feel the [13:41](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=821s) same. [13:42](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=822s) They have the important bits. [13:43](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=823s) If you don't give any guidance on what the [13:46](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=826s) agent should really have, it'll write you [13:48](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=828s) like a giant paragraph, like a story. [13:51](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=831s) And honestly, that's my biggest pet peeve [13:53](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=833s) right now is when people submit PRs or [13:56](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=836s) diffs to review where the summary and test [13:58](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=838s) plan is longer than the code changes [14:01](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=841s) itself. [14:01](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=841s) So don't be that guy. [14:02](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=842s) Now I showed this off a little bit, but [14:04](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=844s) all the agent stuff that I've been talking [14:06](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=846s) about was during runtime, during the [14:07](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=847s) generation of the code. [14:08](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=848s) And that's what you're running. [14:10](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=850s) But then Codex actually offers this [14:12](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=852s) integration right here where you can add a [14:14](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=854s) Codex reviewer onto GitHub and it could [14:16](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=856s) run on new GitHub, like, you know, PR [14:18](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=858s) opens, or you could also like just add [14:21](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=861s) Codex here like that. [14:22](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=862s) And essentially it's this chat to be the [14:24](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=864s) Codex connector. [14:25](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=865s) And I think there's a separate model [14:26](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=866s) slightly that is custom trained just for [14:28](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=868s) like reviewing. [14:29](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=869s) Now all of this costs money, right? [14:32](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=872s) But yeah, that's an example. [14:33](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=873s) Another thing you can do is actually use [14:36](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=876s) goals as an example. [14:38](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=878s) So one of the common issues that people [14:40](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=880s) will run into when they start having these [14:42](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=882s) agentic systems that are reviewing their [14:44](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=884s) code on GitHub is that after you submit a [14:47](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=887s) PR, the agent will go do stuff. [14:48](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=888s) And then it'll give you a bunch of [14:50](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=890s) comments that you need to fix. [14:51](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=891s) And sometimes there'll be a lot of back [14:53](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=893s) and forth. [14:53](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=893s) You fix it and then like you resubmit and [14:55](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=895s) then it'll be like back and forth. [14:57](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=897s) So a thing you can do is like just use [15:00](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=900s) goals to babysit a PR. [15:01](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=901s) So let's say we had this like random PR. [15:04](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=904s) This is a draft, but you could just say [15:06](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=906s) for this PR, can you babysit it every [15:09](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=909s) hour, check it every hour and make sure [15:11](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=911s) that you address any changes requests from [15:15](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=915s) the Codex agent. [15:16](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=916s) It misspelled it, but you get the point. [15:18](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=918s) So what this will do is every hour it will [15:20](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=920s) check that PR and then it will fix any [15:22](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=922s) issues, rerun your local validations, [15:25](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=925s) agentic validations, update the PR notes [15:27](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=927s) and then resend it. [15:28](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=928s) So these are the kinds of things that you [15:30](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=930s) should build into your own skill if you [15:32](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=932s) haven't done so. [15:34](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=934s) But yeah, so those are kind of like the [15:35](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=935s) high level like useful tools in my [15:37](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=937s) opinion. [15:38](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=938s) It's just really important to use [15:40](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=940s) adversarial agent in my opinion, have good [15:43](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=943s) review skills, actually just like the [15:45](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=945s) default like skill reviewers, have a [15:48](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=948s) template for your PRs and you could use my [15:50](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=950s) template if you want, but just have a [15:52](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=952s) template so it conforms your PRs to that [15:54](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=954s) template and then it adds like validation [15:57](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=957s) proof. [15:57](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=957s) We talked about the different types of [15:59](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=959s) validation. [15:59](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=959s) You really want to anchor on the agents [16:01](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=961s) giving you proof that will actually help [16:04](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=964s) your AI coding by the way. [16:05](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=965s) And then you just submit all of that. [16:07](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=967s) And then you make sure you anchor on [16:08](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=968s) safety and gating. [16:09](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=969s) So these are kind of the high level things [16:11](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=971s) that I think about. [16:12](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=972s) Before we end this video, I also wanna [16:13](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=973s) talk about what it means if you're coding [16:16](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=976s) like this, where you're reading some of [16:18](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=978s) the code deeply and you're reading like [16:20](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=980s) leaf nodes kind of like skimming it as [16:22](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=982s) you're going. [16:23](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=983s) The end product of that entire feature at [16:27](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=987s) the end of your coding session, like [16:29](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=989s) you're like, oh, I'm done. [16:30](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=990s) If you actually code in this way, you'll [16:33](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=993s) be only actually like 80% done. [16:36](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=996s) So here I'm saying, even if it's merge [16:38](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=998s) ready, I don't think it's launch ready. [16:40](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1000s) So what I like to do is I call this [16:43](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1003s) initial step of like getting everything [16:45](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1005s) gated and landed. [16:46](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1006s) I call that like broad strokes. [16:48](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1008s) I'm doing like broad strokes of the code [16:51](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1011s) changes. [16:51](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1011s) And then this last like 20% or so is [16:54](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1014s) really getting something launch ready. [16:56](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1016s) And this is where a lot of my human like [16:59](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1019s) effort comes in. [17:00](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1020s) And then I do a lot of refactoring here [17:02](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1022s) and kind of like cleaning up of the code [17:04](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1024s) base, right? [17:05](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1025s) So I actually have a bunch of agents [17:07](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1027s) before I do any launch, I like audit the [17:10](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1030s) entire code that it was written. [17:12](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1032s) And I think about it from high level. [17:14](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1034s) And I think about like important things [17:16](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1036s) like performance, bugs, security, you [17:19](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1039s) know, and then whether the feature [17:21](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1041s) actually works to spec. [17:22](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1042s) And then I'm really like detailing the [17:24](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1044s) animations or anything like that. [17:25](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1045s) And so this last 20% actually takes as [17:28](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1048s) long as the first 80%, but it's actually [17:31](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1051s) the thing that is the most important. [17:33](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1053s) And in my opinion, you're able to move so [17:35](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1055s) quickly in the beginning, but this last [17:37](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1057s) 20% still requires a lot of like, like [17:41](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1061s) human taste factor. [17:43](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1063s) So you still need to look at it. [17:44](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1064s) And this is where my code kind of becomes [17:46](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1066s) a lot more clean and production ready. [17:48](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1068s) Now, finally, when you're ready to launch [17:51](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1071s) the feature, I highly encourage you to try [17:53](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1073s) to run experiments. [17:54](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1074s) So you could like validate that the code [17:56](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1076s) is actually working. [17:58](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1078s) Now, if you have a small user group, then [18:00](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1080s) you can't really run a sizable experiment. [18:02](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1082s) You don't have statistical like power to [18:04](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1084s) even like run legitimate A/B testing, but [18:08](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1088s) I still recommend running A/B tests or [18:11](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1091s) doing like canary deployments, because [18:13](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1093s) what that helps you is if you trickle your [18:16](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1096s) traffic for your new feature through like [18:18](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1098s) feature gating, then you're able to very [18:21](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1101s) quickly see bugs or crashes or alerts that [18:24](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1104s) fire. [18:25](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1105s) And that's the whole point. [18:26](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1106s) You wanna anchor always on safety when [18:28](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1108s) you're using agents to code, because [18:30](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1110s) physically you won't be able to physically [18:32](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1112s) read everything in detail. [18:34](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1114s) It's just impossible now. [18:35](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1115s) So the idea of high level is you wanna [18:37](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1117s) create like an agentic safeguard, like an [18:40](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1120s) agentic garden, where you have a lot of [18:42](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1122s) tests, you have a lot of validation, and [18:44](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1124s) you have a lot of agents doing a lot of [18:46](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1126s) work to make sure your code is good. [18:48](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1128s) But at the same time, you wanna anchor on [18:50](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1130s) safety and make sure you can take back bad [18:53](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1133s) decisions with gating. [18:54](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1134s) So do I review code? [18:56](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1136s) I think the simple answer is yes, but it [18:58](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1138s) really depends. [19:00](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1140s) And it's a gradient, right? [19:02](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1142s) But in my opinion, the models are getting [19:04](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1144s) better and better. [19:05](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1145s) So you will probably review less code, but [19:07](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1147s) you should really anchor on validation, [19:09](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1149s) agentic validation. [19:11](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1151s) And then the agent should like have a lot [19:13](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1153s) of validation and proof and evidence of [19:15](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1155s) the proof, like whether it's video [19:17](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1157s) recording or logs or like just [19:20](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1160s) screenshots, whatever it is. [19:22](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1162s) And then you gate, and then you like start [19:24](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1164s) trusting the agents more. [19:25](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1165s) And as long as you have like control to [19:27](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1167s) take things back with gating, then it [19:29](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1169s) should be safe to go. [19:30](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1170s) So yeah, I hope you guys enjoyed this [19:32](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1172s) video on agentic code reviewing and like [19:34](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1174s) my thoughts on code reviewing. [19:36](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1176s) The thing is this topic keeps changing for [19:39](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1179s) me. [19:40](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1180s) Right now, I'm comfortable with the [19:43](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1183s) skimming of some code, depending on like [19:45](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1185s) where it is and the like tree concept that [19:48](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1188s) I talked about. [19:49](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1189s) But maybe after another few generations of [19:52](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1192s) the model, I might say, you know what? [19:54](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1194s) You don't need to read any of the code. [19:56](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1196s) So who knows? [19:57](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1197s) But right now I think you still need to [19:59](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1199s) like read some of the code and have like a [20:01](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1201s) fine tuned opinion of it. [20:03](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1203s) Now, one last thing that I forgot to [20:05](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1205s) mention is that if you understand your [20:07](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1207s) code base, it's actually easier to review [20:10](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1210s) the code because you can very quickly spot [20:13](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1213s) what's touching like the dangerous zones [20:15](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1215s) of your code base and what's like really [20:17](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1217s) simple and leaf nodes, right? [20:19](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1219s) So yeah, that wraps up this video. [20:20](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1220s) I hope you guys enjoyed it. [20:22](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1222s) I do a ton of these videos. [20:23](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1223s) I did a video on like Codex and Claude [20:25](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1225s) Code, which I think would be very relevant [20:27](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1227s) for this video. [20:28](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1228s) So feel free to check that out. [20:30](https://www.youtube.com/watch?v=b2QkhmQ0sT0&t=1230s) But until I see you on the next one, bye.