Skip to content
476: Green Flags for Code episode artwork

Sep 30, 2025 36 min

476: Green Flags for Code

from The Bike Shed Hosted by thoughtbot

Joël and Sally sit down to discuss their green and red flags when it comes to PR review. Joël breaks down the different ways humans review code vs AI, how they both break down large projects into smaller digestible PRs and clarifying your reasoning for certain decisions, as well as discussing the most common red flags they’ve encountered when looking over code. — Take a break from coding to brush up on your Roman History. Thanks to our sponsors for this episode Judoscale - Autoscale the Right Way (check the link for your free gift!), and Scout Monitoring. Your hosts for this episode have been thoughtbot’s own Joël Quenneville and Sally Hall. If you would like to support the show, head over to our GitHub page, or check out our website. Got a question or comment about the show? Why not write to our hosts: [email protected] This has been a thoughtbot podcast. Stay up to date by following us on social media - YouTube - LinkedIn - Mastodon - BlueSky © 2025 thoughtbot, inc.

Episode details come from the podcast's RSS feed.

Embed this episode

Ready to play

476: Green Flags for Code

0:00 36:39
of matches

Transcript Auto-generated, may contain errors

Autoscaling is a simple concept. Automatically add resources when needed, and automatically shut them down to avoid paying for excess capacity. How hard could that be? If you've set up Autoscaling yourself, you know it's not that easy, especially using the native Autoscalers on platforms like AWS and Heroku. That's why you need JudoScale.

JudoScale is Autoscaling as a service, and they make Autoscaling simple and easy, as it should be. You can use JudoScale on AWS, Heroku, Render, Fly.io, and more. It's free for low traffic apps, and unlimited plans start at $25 per month. Autoscale on Easy Mode at judoscale.com. Hello, and welcome to another episode of The Bike Shed, a weekly podcast from your friends at Thoughtbot about developing great software.

I'm Joel Kendall. And I'm Sally Hall, and together we're here to share a bit of what we've learned along the way. So Sally, what's new in your world? Ooh, I've been spending a little more time sewing recently. I mean, I always do a lot of crafts, but I've sort of taken it in a new direction of trying to alter clothes I already own to fit better or work better for me, rather than getting rid of them and buying new ones.

And it's been kind of empowering, like realizing that I have, it's like a superpower to make these pants fit or make that dress less ugly. So I've been doing a lot of that, which has been really fun. That's really cool. Because I feel like custom tailored clothes that work for you is a luxury. It's a kind of thing that you do pay professionals to do for a special piece, and having the ability to just do that to your normal clothes is really nice.

Yeah, it's been really good. And the clothes you buy in a store are made for one particular body shape that most humans don't have. So none of us can really get great fitting clothing off the rack. And so it's been really helpful for me to start to learn about how to make little adjustments. These are not, you know, I'm not like tailoring a suit.

I'm like taking in the waistband of a pair of pants, but it still feels pretty tremendous. Yeah. What about you? What's new in your world? I've been sort of going on a deep dive on, there's a blog that I follow by ancient Roman historian.

He's been doing a series on ancient, but sort of more broadly, all periods of time, peasants and what their lifestyle is like, what are their very economic incentives that impact them? I think it's really interesting that he notes that when you study history, you often pay a lot of attention to sort of the kings and the nobles and the priests and the type of people that are either writing history or having history written about them. But the majority of people across all time and places have been peasants. And so he's doing sort of a deep dive on like, what is it like to live as a peasant? What are peasant households like?

What are their sort of land tenure? What is it the interactions with each other, with their neighbors, with the sort of more wealthy people around them? It has been really fascinating. And it's put that in an article every Friday and maybe halfway through. And it's been going on for a few months.

So if you really want to nerd out on some things, if you want to look at some actual statistics, dig into things like life expectancy and fertility rates and things like that, patterns of family formation, you can go as deep as you want. That actually sounds really interesting to me. I've never been a huge fan of history, but as I've gotten older and experienced history, learning about history in different ways, I really like historical fiction that's focused on not the ruling people, but the everyday people. It's been a lot more interesting to me. Also, it surprises me not at all that what's new in your world starts with ancient Roman history.

On brand. Definitely. I want to check that out. I think I would enjoy that. And we'll include a link of the show notes for anybody else who's curious about the series.

I was going to ask, I think a fact that I've seen in like totally non-reliable Instagram factoid areas is that ancient history peasants actually worked far less than we do today's modern people. Has he talked about that at all? Yes, I think actually part of the reason he's wanted to talk about peasants for a long time. But I think part of it, he's been seeing that come up a lot and it's a fact that he's trying to debunk. Okay, so it's not true.

According to him. He sort of tabulates a lot of what the labor is that goes in. So if you want to do the math, it goes into a lot more depth. One of the things that's kind of crazy for us in terms of the sort of amount of leisure time that we have is just having a weekend. Yeah, that's a relatively new thing.

Once you count up the days and you take out the weekends, it's not that many days a year that we work. So if you were religious festivals and harvest festivals and things like that, then a peasant would. But we only work five days a week. That's really nice. And a lot of people in today's world get time off rather than like, I know not everybody does.

It would be great if we did. Time off vacation or sick days or things like that, which I don't think was an idea back then. The peasant couldn't just tell the overlord I'm going to go to Italy for a week. See you later. Right.

The idea of going off for a trip is very uncommon for peasants. To certain extent, they have control over their schedule if they're working their own land. But that's still you got to get your harvest in and it's an awkward time to get sick. Yeah, you're taking all the risk there too. You're working on some pretty slim margins too, right?

You want to survive the winter and you want to be able to feed your family. Yeah, the stakes were very different. Well, I mean, I'm sure that those are the stakes for a lot of modern people. But generally, software developers are not struggling to get all the code written before winter. That's right.

Yeah, trying to hope that we have enough database seeds to plant next spring or something like that. Yeah. Grow delicious, delicious. SQL queries, I don't know. Yeah, yeah.

Look at that. Those fertile servers and grows some real high quality code. I guess on the topic of high quality code though, I'm curious. When you review pull request, you know, somebody sends you a link, maybe there's a lot of code in there. Do you ever sort of use some of the heuristics to just sort of like scan it and get a sense of like maybe what the quality is of this PR in general?

Oh, yeah. I think we all do. It's funny that you said there's a lot of code in there because that's actually one of my first ones. If you've opened a PR with 1500 lines of actual code changes, you know, not like, oh, I've pulled in this giant library, immediately I'm going to be a little suspicious about the quality of that code. Not because writing a lot of code inherently is bad, but because I think the process of thinking through it and breaking it down into smaller steps and smaller PRs, even if you do that after the fact, is an important part of like thinking through the code and making sure you're writing the correct thing.

And if you don't take that moment to do that, then my first thought is going to be how much of this is just like over engineered extra circling around the point code that could have been done smaller. What's the famous quote? Like, I've only started this letter so long I didn't have time to make it any shorter. I feel like I've heard attributed a bunch of people. I think most commonly I've heard Mark Twain.

Yeah, that's what I was going to say too. But yeah, yeah, so sort of that thought. The code is really long. It makes me feel like they haven't taken the time and effort to make it shorter or to make it in chunks. And so that's going to be a red flag.

But I guess in the opposite if we're talking about sort of like what signals good code, like really concise, focused PRs with good descriptions. I love that. There's nothing better to me than like a two line PR with like a six paragraph PR comment, which is maybe a little bit over the top. But like, that's just so beautiful to me when you found a way to make the code actually concise and you're taking time to sort of walk your colleagues through what you're doing, why you're doing it, maybe why you didn't do other things. I found that those types of PRs like two line change, you know, blog post in the description often are tricky like bug fixes or security patches, things like that.

Things where it took me all day to trace this and figure it out. And eventually it was a one line fix. But there's a story here and there's a lot of context that you need to know because again, this is the sort of thing that's gone through review for a lot of people and nobody, everybody missed the bug because of more complex factors. So there needs to be an explanation. Maybe talk about experiments that I ran, like how I got there, how I proved that this is in fact the case, maybe some benchmarks for before and after.

A test for that regression. That's another thing I like is when there's a little change, but like a substantial, not over tested, but like enough testing that we can feel confident that we aren't going to have to fix this mistake again. Or even like guide rails for making it difficult or impossible to make the same kind of mistake in the future. Right. Right.

I want to only make every mistake once. Yeah. The worst sort of those recurring bugs where you think you fixed it and then it starts breaking again in a slightly different way next week and it's constantly the same bug popping up. Yeah. Those are so frustrating.

And it's so like, I feel like that always points to like, this is a process problem, how do people problem? Like we're all thinking the same way and making the same mistake. So it's not any, I mean, I feel like I really want to throw a blame around anyway, but it's like certainly not anybody's fault because we're all making the same mistake. So there's something going wrong with our processor, the way we set up our repo or something that is making this easy to do the wrong way. What do you look for in NPR?

Oh, I think similar to you before I go anywhere, get a sense of the description. And then also like you said, the link, partly just because I need to budget how long I'm going to say here for. Yeah. And I think that I've learned is that like if you just sort of start and you're doing sort of in-depth review on code and you don't really pay attention to the link, it's easy to go really into details on things and you realize, wait, there's not a thousand lines here and the real, I've got some meta feedback here about like, your approach in general maybe could be restructured. And so like the type of feedback needs to be at a different level.

And so getting that 10,000 foot view of what the PR is about before I actually look at the code in detail is I think an important step. Yeah, absolutely. Yeah, I've definitely gotten into a situation where I start reviewing code and you know, maybe I skip that overview step and start leaving comments on like little things like syntax or whatever or suggestions for small improvements. And then about halfway through I realize, oh, this I want to suggest an entirely different approach. And so now all these comments I've spent time making are kind of irrelevant.

Exactly. I think maybe also having changes focused in just a few files tends to also be a green flag for me. If something is touching 50 different files across a thousand line diff, I know this is a real rough kind of scpr. Yeah. And maybe there's a valid reason for it.

So again, these are sort of green and red flags. They're not necessarily for sure that your code is bad, but they're definitely a raised in eyebrow. Take a look at it more. If something is on the shorter side and only touches a couple of files, that to me is a sign of like, okay, this is probably a decent quality code. You guys sit down, understand it.

And it's probably relatively easy to approve as well. I think related to that, I also really like concise, well named methods. Mm. You know, if I am looking at a method that you added to a class and it's like I have to really sit and partially every line before I even understand what it's doing as a whole, that to me can be frustrating. But if I see a method and just by its name or something about, you know, I can know what it's generally trying to do, I think that's really helpful.

And I can, you know, with the idea of what this is doing, I can see that in the context of the rest of the code without first having to parse the whole method itself. Yeah. Yeah. You can do like a high level review of like, what are these things called and how are they interacting with each other? And then second level, okay, now let's take them one by one and see how they're doing those things.

It's almost like a writing parts of your code at a high level of abstraction. Yeah. Yeah. So it's a little bit longer if you're pulling out a lot of like private methods to give names to complex behavior. That's true.

Yeah. So that's going to be a situation where longer is better, which I think is can also be, yeah, really good indicators that, you know, sometimes there's something that you can do in a really cool way in one line that feels very snazzy, but can be difficult to parse difficult for a human to read, which then makes it hard to maintain a debug. And so taking the time to break that out into smaller steps, I think can be a really good sign. You know, the idea of like, some people will only like extract a method if it's being used in multiple places. But I think extracting a method that is only used once can sometimes be helpful if it makes it more readable, more manageable and more maintainable.

Have you ever tried to debug an issue in production while switching between your error tracker, log viewer and APM tool? Maybe you know how painful it is when you can see the error, but can't find the relevant logs or when you see slow performance, but can't connect to the root cause. Scout monitoring is the all in one platform built to make your life easier with log management, performance tracking and error monitoring coming soon. All of your data will be together at last. We'll go from bug to fix in one place.

The result, less context switching, faster debugging and monitoring that actually helps you ship code instead of distracting from it. No DevOps team, no problem. Scout works with your existing stack and gives you insights in five minutes, not hours. From bug to fix in one place at ScoutAPM.com. I'm a huge fan.

I've talked about my sort of trio of principles I call the triangle of separation on the show before. They all sort of converge towards the same set of, I guess, the same style of code. Those being right coded as single level of abstraction. So don't mix high in the level code. Separate branching code from doing code.

So if you're doing conditional, you don't get to have an implementation in the branch of the conditional, you can only call other methods and then finally push conditions up the, or push conditionals up the decision tree. Turns out that all of those sort of, I think, converge towards the style of code that we're talking about right here, which is at sort of a high level, you have a sort of almost like domain method on your object that is implemented in terms of other things internally, but they're all just sort of high level calls. So you get a sense of, okay, this is what this method is doing and then you can drill down into any of them if you want to see what the implementation is. I just thought of another, like PR related thing that's not necessarily how the code is written. It is just a huge green flag for me.

And I'm going to call out one of our teammates Justin, Tanya, who I'm lucky enough to be working with on a project right now. It does a great job of not only doing a great PR description, but then commenting on his own PR at points where code might need additional explanation or clarification or questions. So reading through a PR, there'll be the description and then there'll be parts of it where he might say I thought about approach A, but went with approach B here because of XYZ in line, which I think can be really helpful for going through a PR and sort of understanding the work that went into it. That is something that I really appreciate seeing, like you said, either in line or in the PR description, the alternate approaches that were considered but not taken because if not, I'm the reviewer and I'd be like, oh, have you considered taking this approach?

And it's nice to be able to know, yes, they did. And they chose not two for these reasons. I think a variation on that can also be I chose this approach for now, but if something changes and these other conditions apply in the future, we should consider doing this other approach. Yeah. So this approach now is urgent bug fix, but I think we should fast follow refactor this way.

Yeah. I think the version of it that I've seen a lot is the we're doing more minimal implementation here than we sort of made these trade offs to say, look, this is going to shift faster or this is going to be smaller for our initial launch or whatever. All the other things that we looked at are potentially nice, but we haven't quite been able to justify the need. But in six months, we may want to evolve this in this direction, which can also be calling out why you've broken something down in certain ways, too. Right.

So like if I've got a big piece of work that I'm working on and I decided that it actually needs to be split into three or four PRs, if my teammates are aware of the problem I'm trying to solve, they might see the first PR and be like, this is an incomplete solution. Right. So putting if you know that you're doing working chunks, putting each chunk in context of the other chunks and linking to things can be really helpful. So something like, you know, this sets up the whole backend, but the front end part of this will be different PR or like, this is all of the- I don't like that style. I don't like that style for a ticket, but I think sometimes that can be really useful for PR, especially if you're doing complicated front end stuff.

So I might start out with here, I'm going to add some models that we're using and sort of set up the structure of this data and then actually use the data in a subsequent PR just so that they're easier to review one by one. I tend to like to do things as full stack as possible and sometimes you have to split it that way. But I like every PR to actually deliver value rather than just sort of, I guess you can have like a refactor PR that's maybe delivering value in a different way. I usually try not to add dead code that's like, oh, I added models, they don't do anything. Eventually I'm going to wire up a controller and then eventually I'm going to wire up a view and sort of work across the stack rather than each layer at a time.

That's interesting. I also do that when planning work and I want to have the person who owns the piece of work owned the whole stack, ideally. But I think breaking it up front and back end or database controller or something can sometimes be a helpful way to break it down. As I'm saying this though, I'm realizing that that definitely leads to situations where it's like the model on its own kind of makes sense but without knowing how we're using it, I can't know and then the next PR comes that's the controller using it and now the model seems off. Right and you have to refactor the model as part of the controller PR.

So given that, how would you want to break down a big piece of work that you don't need to be broken down into smaller PRs? I usually break it down by ticket. So like you were saying, you like the tickets to be full stack, I will try to make the tickets really small where each ticket is delivering an actual little chunk of work, some amount of value and maybe that ticket is doing something really, really minimal. So there's a dashboard that you want. It has to be full stack and there's all these complicated behaviors on it and maybe version one is just there's a dashboard that prints your name and that is it.

But everything works full stack. Then one by one, maybe I introduce sort of one widget at a time on the dashboard, but full stack. But find ways where each commit is delivering some small new feature in DAN. The tricky thing there is that you have to learn to really split features rather than architectural layers and that's hard. Yeah, I think the work I've been doing recently now that we're talking about it, I could be breaking it down better, which is something that I usually feel like I am good at and proud of.

So I'm going to take that back with me this week and see, start focusing more on is this ticket too big? I think practice is also very within teams. So I've been on teams that have been like sort of really heavy on not doing this in this way. So I might bring a little bit of that to the team, but I'm not going to force them to re-chain it, like totally redo the way that they work. Yeah.

There's a hey, you know, there's some value in like scoping your tickets smaller because it allows you to ship faster, it allows you to get better reviews, that kind of thing. It's also really helpful for isolating breakages, right? So if I've merged two giant PRs this week and then the code stops working, it's a lot harder to focus down on exactly which change caused the problem. I wonder if there are maybe some language specific things for you as well. So I know you've been working on a lot of more React code recently.

Do you find the way you review or even give that sort of two minute analysis at the beginning of a PR before you dig into review? Is that different when you're looking at a React PR versus a Rails PR? That's a great question. Although ideally, you know, shouldn't it be both because we're doing the full stack? I think it can be really tempting to cram a whole bunch of stuff into one file in a React PR in a way that is, I think, more natural to avoid in a Rails or Ruby PR, which could just be a reflection of my experience with it.

The structure of a Rails app is more intuitive to me at this point than a React app. But I also see, like, you know, we're making this huge change and, you know, I don't necessarily want to see something that touches every single file, but I also don't necessarily want to see something that triples the size of this one file when it might make more sense to break it out. And I think part of the temptation there is that having to import and export things can make attempting to be a little bit lazy about that. And like, you know, if I extract this out into a whole different file or whatever, then I have to import it here where I want to use it. So I'm just going to put it all here because it's easier, which I think is less of a temptation in Rails world because you don't have to be directly importing and exporting things like that.

So that is definitely one thing I look for is like, have we crammed a whole bunch of stuff into one file that actually belongs separate? So as a sort of a green flag, if you're looking at, if you're scanning a PR to get a sense of very rough, almost internal grade for the quality of the code, seeing the React code, if it's over a certain size, maybe in a few different files is a thing where you're immediately like, okay, that feels good. Yeah, we're seeing something where I can look at the list of files. If you look at the list of file names that have been changed or added, you can get a sense of what are we doing here? Like, what's the purpose of this PR?

Right? If it's a PR, if every PR just changes like the index file, then I don't really know what's going on. But if you've added, you know, some, we're doing the text group also, which is a fun new adventure for me that I actually love. But if you're adding a couple of types and then adding a component that you then import into this page, sometimes you can get a better sense of what is the overall approach to this change just from reading through the file names. And so I think if I can sort of read the PR description and then take a glance at the file names and see what's involved, that can often give me a good gut check of like, where is this going?

What story are we telling here? Like a table of contents? Yeah. So the GitHub will give you that, like, gutter on the side that shows you all of the, like, a little file tree. Yeah.

Is that something that you find yourself scanning at the beginning of a code review? Absolutely. Yeah. A lot of times I scan that and then like to start with the tests, you know? So it's sort of like a bottom up reading thing because a well written test is often a guide for like, this is what I think this code should do and this is how this works and this is the story I'm trying to tell with this, which might be a cheesy way to think about it.

But like, if you're trying to add value with every PR, then there's a little tiny user story in there that you can tell and you can tell it well. Yeah. So scan the file thing and then sort of start bottom up. Well, at least the structure of the projects I'm working on, the tests tend to be at the bottom because test is alphabetically later or spec. Yeah.

So scan that, start bottom up, start to see like, am I understanding where we're going with this? Which I'm starting to see a pattern of the things that we're saying is that like being able to approach it high level and then like sort of more detail and then more detail as you go into the code review, feels like a good sign as opposed to I have to absorb every single detail before I really understand what's happening. Yeah. So almost like the fact that the code can be read at multiple levels of detail is itself heuristic for code quality. Right.

Which I sounds like it could be contradictory to your guideline of writing at like one level of abstraction. But I don't think it is. I'm not saying that the code should be abstracted at different levels, but that I should be able to absorb it at different levels of granularity. Right. And get more meaning as I go deeper for each one.

And I think you can get that a little bit just from the structure of a Ruby file, even if you're using the approach that I'm using because all the like implementation details end up in private methods. So you just sort of scan everything above the private keyword and be like, okay, this object does two or three things. This is a public interface. And each of them looked like they call, you know, a few private methods, they're named with the behavior that they do. So I guess sense that like, okay, this thing is making network requests and constructing an instance of a value object or something like that.

Or this is validating an input and writing to a file without necessarily knowing the details of what that validation is. Yeah. I don't think I thought about explicitly like that before, but the idea of like the public code is what it's doing. And then the private code is the details of how it's doing it. Yeah.

That is an interesting way of putting it. But it's sense because if we're taking that even more abstract before we've even gotten into the code when we're talking about value to the user, like the user story or ticket description or whatever, it's going to be what we need to do, but not how we need to do it necessarily. So as you get deeper into the code, it's more how. And hopefully, you know, that's sort of the level at which your specs are written. So this conversation partly came out of a broader conversation around AI tooling in the workplace and how it often creates artifacts that sort of look polished, but then when you dig into them or not.

And that got me sort of wondering about, you know, what is polish or signals that we have that code is high quality when we're looking at code rather than a slide deck or something like that. I feel like a lot of the signals that we talk about are a little bit harder for AI to replicate. And I think PR descriptions in general is an area where I've seen AI just fall flat because it summarizes oftentimes the diff. They're beautifully formatted though. Yeah.

Yeah. And it's probably not a bad thing. I probably wouldn't hate having like just a button to summarize the diff in GitHub. Less is a PR description because I feel like I want other things when I read a PR description. But sort of additionally, if there was just a pop up a modal and give me a summary or give me a sidebar or something, that might not be a bad thing either.

But I think in a description, I'm looking for more sort of the purpose of the PR paths that we went down and chose not to take trade offs that were considered general sort of architecture strategy, things like that. So what are some things that we think might be stuff that AI or, you know, insert other creator of code might do that appear to be signs of good code, but that are not, right? So like what are some of the like shiny wrappers that don't actually signify what they seem to it first? And I guess I can start. One of them I think is really long thorough tests can look like a great thing.

And I do love well tested code, but I find that AI will sometimes generate a really long test that actually ultimately doesn't do anything. And tests are often something that we, people don't review quite as much detail. So it's easy to forget those just merged and maybe there's some sort of things that are not as valuable. Yeah. And I think like one of my heuristics work that I read a good test or not is if I remove the code that I've included in this change, does this test fail?

Right. So I think that's a really beautiful looking test that seems to be doing interesting and worthwhile things. And then they don't actually test the changes even. That's a challenge to think even when you're manually writing your tests, if you're using a test after approach, and I often feel like I can tell just by reading the spec, whether it was written test first or test after. That's interesting.

Just because writing test after you're now aware of your implementation, that causes you sometimes to write the test in a different way. What does it look like when a test has been written after? Can you identify some sort of like signs or patterns that you see in those? It tends to be more coupled to the implementation that might do some more mocking. It might be tied to particular methods being called, that sort of thing.

It might be also the setup data might be done in a way that's like very particular to a way that a method has been structured in a way that's not necessary if all you knew was the interface. So like there's some secret data tricks you have to do for this test to do what we want it to do that aren't. They're not even required is the thing, right? Oh, okay. But because you happen to know that it's implemented in a certain way, you wrote the setup data to kind of match that even though it's not necessary for the data to be in that way.

Yeah. So maybe it just so happened that you wrote it that way, but odds are you wrote it that way because you know of the implementation already. It sounds like the resulting tests for those two approaches would be, you know, the test first approach would probably produce a simpler and maybe smaller test than the one where we're digging into where you can tell that we are relying on the implementation details or the complicated setup. Does that sound true? Yes.

I think when you write test first, you often are testing more of the interface. So you say, given these inputs, I expect these outputs or I expect these side effects. And the how we get there is sort of up to when I get to the green phase of my TDD. I have gotten AI agents to do TDD. You have.

I don't know that I've really put much thought into seeing if the style of tests that creates are different with one form versus another. So I know humans tend to over-mock when they test after. And oftentimes if you're testing first and the test is painful, then that leads to refactoring your implementation. And I have seen situations where AI over-mocks as well. And I think those situations have tended to be, here's an implementation right at test for it.

It's quite possible that having a TDD helps reduce that behavior just like it does for humans. But that's not a thing I've paid attention to. That's a really good question. I would be interested to sort of explore that and see, you know, does asking an agent to approach it in a TDD way improve the results? It seems like it could because like you were saying, as a human doing tests first, I'm going to get a deeper understanding of what's going on.

And I hesitate to use the word understanding with AI, but it does seem to have at least better context, you know, if it starts with what you're actually trying to accomplish rather than what you've already written. It's almost the, like knowing the implementation almost like pollutes the context. I feel that happens to humans. But I wouldn't be surprised if there's something kind of like that that happens for the AI as well. Maybe do some experiments.

We should follow up on this and see, try to come back to this later. Have we done this experiments? What have we learned? Uh-huh. Yeah.

AI tests. Yeah. Something to maybe talk about in our recap episode at the end of the season. On that note, shall we wrap up? Sounds good.

Frequently asked questions

How long is this episode of The Bike Shed?

This episode is 36 minutes long.

When was this The Bike Shed episode published?

This episode was published on September 30, 2025.

Is there a transcript available for this episode?

Yes, a full transcript is available for this episode. You can read the complete transcript on the episode page.

Can I download this The Bike Shed episode?

Yes. Use the download control on the episode player to save the publisher-provided media file.