Skip to content
445: Working Iteratively episode artwork

Oct 29, 2024 40 min

445: Working Iteratively

from The Bike Shed Hosted by thoughtbot

Does having smaller, more frequent iterations help to ease your cognitive load? During this episode, we discuss the benefits and challenges of working iteratively and whether or not it can prevent costly errors. You’ll hear about juggling individual pieces effectively, factors that incentivize and de-incentivize working iteratively, and how Joël gauges whether or not a project should be broken up into smaller tasks. It can be hard to adopt small iterations, and this conversation also touches on the idea of ‘good enough code’ and discusses how agility can reduce the cost of making changes. Tuning in, you’ll hear about some of the challenges of keeping up with changes as they evolve and why it is beneficial to do so. You will also be equipped with a thought experiment involving elephant carpaccio to build your understanding of working iteratively, explore the challenge of keeping up with evolving changes, and more. Thanks for listening. Key Points From This Episode: Stephanie shares a recent mishap that happened at work and what she learned from it. Unpacking pressures and other aspects that may have contributed to the error. Joël’s recent travels and his fresh appreciation for fall. The cost of an incident occurring, how this increases, and the role of code review. Benefits and pitfalls of more regular code review. Why working with smaller chunks of work is helpful for Joël’s focus. Juggling individual pieces effectively. Factors that de-incentivize working iteratively such as waiting on 24-hour quality control processes. How working iteratively can facilitate better communication. Why Joël feels that work that spans a few days should be broken up into smaller chunks. The idea of ‘good enough code’. How agility can reduce the cost of making changes. Using the elephant carpaccio exercise to bolster your understanding of working iteratively. The challenge of keeping up with changes as they evolve and why it is beneficial to do so. Involvement from the team and the capacity to change course. Links Mentioned in Today’s Episode: WorkOS Working Incrementally Working Iteratively Elephant Carpaccio Exercise The Bike Shed Joël Quenneville on LinkedIn Joël Quenneville on X Support The Bike Shed

Episode details come from the podcast's RSS feed.

Embed this episode

Ready to play

445: Working Iteratively

0:00 40:06
of matches

Transcript Auto-generated, may contain errors

This episode is brought to you by WorkOS. If you're building a B2B SaaS app, at some point, your customers will start asking for enterprise features like single sign-on, SCIM, provisioning, role-based access control, and audit trails. That's where WorkOS comes in, with ease-to-use and flexible APIs that help you ship enterprise features on day one without slowing down your core product development. Today, some of the hottest startups in the world are already powered by WorkOS, including ones you probably know, like Perplexity, Vercel, Jasper, and Webflow. WorkOS also provides a generous free tier of up to 1 million monthly active users for its user management solution.

making it the perfect authentication and authorization solution for growing companies. It comes standard with rich features like social logins, bot protection, MFA, roles, and permissions, and more. If you're currently looking to build SSO for your first enterprise customer, you should consider using WorkOS. Integrate in minutes and start shipping enterprise plans today. Check it all out at WorkOS.com. That's WorkOS.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 Joelle Kenville. And I'm Stephanie Min, and together we're here to share a bit of what we've learned along the way. So Stephanie, what's new in your world? So I caused an incident at work last week. So that was not totally new because I have before, but I did want to bring it up because it happens and it's just part of our jobs. Did you delete the prod database? No, nothing like that, but it was still bad. It had a very large customer impact.

I was running a really big planned migration, and I think we had made some assumptions about the relative risk and safety of it. Specifically, I had set this up to not kind of... thinking that it would not involve impacting existing records, but just kind of very deep in the code, some kind of weird emergent behavior that I wasn't expecting did happen. And that had another strange side effect that wasn't kind of handled correctly somewhere else in the system. And it happens. So yeah, I think that what I wanted to mention specifically about the incident, though, was that we had a retrospective on it a few days afterwards, where the people who were involved with triaging and resolving the incident, because it wasn't me, it happened over the weekend, and the folks who were on call had to deal with it, all of us got together and just...

talked about the facts of what happened and then areas for improvement, specifically at a system level. And one of the things that I really, really appreciated about this retrospective was how blame free it was. And yeah, just not kind of calling any individual out, right? It was a system failure because there were a lot of things that went wrong in order to have had like the magnitude of impact that it did. So I really just appreciated how open everyone was to thinking about like, what can we do at all different levels of the system to have prevented something like this? And just really learning from.

what happened and how we can better monitor things, get earlier signals, earlier and clearer signals about what was going on before it had touched so many customers. What was that sort of post-mortem structure like that made it so blame-free? Yeah, I think one thing that was really nice was the facilitator set the table with some ground rules at the beginning. Kind of, like I said, really honing in on the idea that there wasn't any individual failure. That doesn't mean that we don't kind of...

be around the bush. If someone did make a mistake, then that's okay. And there was another phrase that I really liked that says, I can't remember exactly the wording, but it was the idea that like, yes, like human error happens, but like that's not the end of the conversation, right? I like that idea that while it's okay for things to kind of result from human error, now let's keep going, right? Let's dig into that further. There's still more that we can do rather than chalk it up to any single mistake. What would you say was the purpose of that meeting? I think it really contributes to the idea that it's okay to make mistakes.

in this like engineering culture, which I really like a lot, and that mistakes are always an opportunity to learn and make our systems more resilient. And being able to take that time to reflect on that, I think is really important, not just for kind of, again, just, you know, now I know that I won't make the same assumption that I did around, you know, what parts of the code, like what I changed touch, but also the idea that when an incident does happen, like it's also not just customers who are affected, but kind of the support team. The folks were on call and like there is some understanding of like it happens. But then also like how did that go? Right. How did the instance response go? And are there areas of improvement we can do there? I think that all around this idea that it's not that we expect things to go wrong, but when we do, we are able to just evaluate like how did we respond to it and what can be improved there as well. So I think it is a bit of a two-parter like preventing them and also kind of looking at the process that happens when they do happen. How would you compare the process for this particular team to other times where you've been in situations where incidents have happened?

Has the team handled it differently than things you've seen at other times in your career? Oh, that's a good question. I am not sure that I have seen or experienced this, but one thing that I would like to see more in something like this is not just looking at the technical parts of the systems. We did talk a lot about adding more monitoring for a particular microservice because that was definitely one of a crucial issue. came up in this particular incident. But we also kind of talked about whether we should be releasing really big things or running big migrations on Fridays, which is what happened in the situation, because that was extra challenging to have to kind of get people together to fix it over the weekend. And there's so much to it that's also, I think, related to team and...

processes. I was curious about, okay, rather than this idea that we should be more hesitant to really speak things on Fridays, I'm wondering if there's some kind of pressure for people to release things on Fridays, especially if this is a bit of a pattern where we may be pushing up against the edges of a deadline or something. And those decisions that people are making, what is going into that? I definitely wish that sometimes we could think about things just beyond the scope of the timeline from whenever it started to whenever it was resolved. I think that there are definitely influences beyond that. That would be really interesting to come up in conversation.

So looking at sort of the incentive structures and social pressures that could also lead to that. Yeah, definitely. So Joel, what's new in your world? So I've recently been doing some international travel. I was gone for a couple of weeks. And when I came back to Massachusetts, where I live, it was kind of hitting peak fall. And fall in this region is just really beautiful. The leaves turn bright colors. And it's actually a tourism thing. People come here.

to see the leaves. It's not the only region where that happens, but it is a region. And I've lived here for a decade. I'm used to sort of seeing that happen. And you can really just get used to it. You're just like, oh yeah, you know, every day the leaves get a little bit progressively more and more colored. When you're gone for a couple of weeks and you come back and all of a sudden, boom, it's there. It really is impactful. And here's this amazing thing in my backyard that I think really hit me on my return home. Yeah. As I mentioned kind of a couple of weeks ago, recently moved to the Northeast and I'm also enjoying the fall colors. And I think like it's so easy to just, yeah, when you're experiencing the transition, like it's happening around you, it can be.

difficult to notice sometimes. And so I really love the idea of you leaving when things are still pretty green and coming back and like, boom, just everything is so vibrant and colorful. I think fall might be my favorite season. And I'm really happy to be in this part of North America to get to experience it this year for the first time. Are you a fall rituals kind of person? Fall decorations? Fall holidays? What gets you really excited about fall?

At my old place, we did have a skeleton that we named Gary that would come out every year in October for Halloween. Sadly, we had to leave Gary behind when we moved. But yeah, I also, this is just a side note, but I think I might be getting over the skeletons. I think they're becoming a little bit too trendy, specifically the 20-foot ones, 20-foot Home Depot skeletons. I think we were, a lot of people got on that train. But I mean, this is very silly, but I really, really like my fall wardrobe.

I'm always excited to break out the sweaters every year. And yeah, I don't know. I think there's something really particular about it that definitely feels like something has changed more so than other seasons. Maybe it's also like the whole back to school kind of energy as well. I loved going back to school as a kid. I don't know why, but I loved it. I think, yeah, it was just really exciting to me. It's almost like a second New Year's. Yeah, that makes sense. I feel like I'm in the greater Boston area and there's just so many colleges and universities here that the town kind of runs on a school calendar.

To the point even where most leases, if you're renting an apartment in the city, go from September 1st to September 1st. And you can find a few outliers that are at other random places. But for the most part, people rent from September to September. And that means that September 1st is moving day for the entire city. It's chaos. But it is kind of that. Like, oh, yeah, the students are coming back. And oh, now he's moving day. And now we're in a new sort of new school year. Yeah, turning over a new leaf as the leaves turn colors. See what you did there. Thank you. I really enjoy, when it comes to fall, getting into fall soups.

And all the fun, like, ball vegetables start coming out, the different squashes and pumpkins and things like that. I think once the air just starts getting a little bit cooler, having something that's hearty and warm is really comforting. Agreed. So the thing that you highlighted earlier is something that really interested you in a kind of postmortem situation is analyzing the social incentives that cause people to choose to do things that then maybe end up in an incident. And that is similar to the way I started thinking about why it's so difficult for some organizations or some teams to adopt a more incremental approach to development.

chunking work into smaller pieces, shipping more frequently, reviewing smaller pieces of code at a time, which is a thing that I often like to promote. I think it's a really helpful way of developing, but there is a cost. And some of that can be technical, but it's not just technical. And so an area that I've been thinking about more recently is sort of what you were talking about, the idea that there are also some sort of social or even process incentives and costs that make it harder to adopt an incremental process. Yeah. This last project that I've been working on, I think I have been taking that philosophy of working.

iteratively. And that experiment for this particular client and project has been really interesting because it always ends up feeling a little bit different depending on the environment you're in. And I think those are those structural things that you're referring to in terms of how effective it can be. And one of the things that I was noticing... was, for example, I ended up having to deploy to staging pretty frequently to test my changes because just there was some parts that could only be tested in a deployed environment. And staging was also kind of a resource that people were, how do I say this nicely, competing over, right? It's like, there's only one staging environment. We all need to use it. And so when I did have a lot of kind of pieces of incremental chunks, like I was needing to deploy quite frequently and sometimes waiting on other people to finish what they were doing. I'm sure I was hogging it a little bit, so I was blocking other people. So when you were talking about the costs, I think one of them can be...

the time it takes for your deployment, right? Like that is a cost in time. Things like that, that I didn't fully think about until I kind of experienced some of those things. Did that experience lead you to build work in larger chunks or maybe to bundle more small chunks together so that you could get that time on staging? Sometimes, yeah. Yeah, that's really interesting that you brought it up because it was kind of like an opposite tension that would encourage me to be like, oh, like, let me just bundle up these two commits that could have been separate together so that I can just test them in one go and be done with it rather than dragging that process on a little bit.

I think a classic thing when you're looking at performance is that if you have a small cost that happens on a thing that happens once, you might not care about it. If the thing where you're paying the small cost happens 100 times or 10,000 times, you start caring about it a lot. And I think we see that when we're increasing the amount of iterations, when we're chunking up work smaller. It allows us to iterate faster. But if there's a thing that you're paying per iteration, any cost there all of a sudden is going to start standing out as much more expensive. Yeah, I like that. So I guess that actually leads me to thinking about code review, because that would be a thing that...

increases in iterations, right? More frequent code review. And I do think it's a tricky balance because at the same time, you're reviewing smaller changes. So there are wins there, right? It's just like less stuff to have to wrap your head around. Do you see any costs to having to do that more frequently? So I've been in organizations where the culture of reviewing is like just really slow. So you ask someone for a review and you're definitely not getting feedback until the next day.

And that definitely then leads people to bundling changes together because if I ask twice, I might have to wait two days or something like that. That becomes just untenable. So there's a cultural element here. But there is a practical element that you mentioned that sometimes the reason it's so slow to review is because you're sending up 1,000 lines of code to review or 500 lines of code to review. And that can take a lot of time. And code review, in my experience, is not linear. Doubling the size of a PR doesn't take twice as long to review, assuming we're talking about the same amount of complexity. It can be three, four times as much effort to review. So you can, if you have a bunch of little ones, make it much easier for...

review to happen. But it almost feels like there's maybe a balancing or teetering point, where on one side you fall into a virtuous cycle of PRs are small to review, and so people feel much more comfortable to, in between other tasks, like, oh yeah, I've got 10 minutes, I can review Stephanie's PR. And then that leads to more frequent review, and it just leaves everybody moving faster. On the other side of that pivot point, though, you can almost fall into a vicious cycle, where it's like, oh, well, Stephanie asked me to review her code, but I know if I do that, I'm going to have to sit down for an hour, or I have to sit down for 30 minutes. And then it's going to be a big back and forth, and we're not going to get through the whole thing until tomorrow, because there's so many changes requested.

which then leads to me not wanting to do that as soon because I need to plan some time on my calendar, which then leads you to bundling more changes and bigger PRs. And then that kind of snowballs out in a negative side. I don't know where exactly that pivot point is, though, where you go from sort of running away into more of a vicious cycle versus a virtuous one. Yeah, I like those two distinctions. The other thing that I'm sure kind of adds to that as well is context switching. I would be curious to know if having smaller, more frequent iterations actually helps with the cognitive load of like...

Just kind of being able to even remember some of the changes, like the smaller changes that happened more recently, and that being like top of mind, as opposed to having to consume it all in one go. And like you said, like really setting aside time to be able to see all of that big picture is if that just the smaller, more frequent pace helps with focus in that way. I don't really know, but that would be a really interesting thing to observe. Anecdotally for myself, I would say that working in smaller chunks, especially if you like bound it well, definitely helps me with my focus and allows me to move faster. It also means that I can context switch away and I don't lose a ton of context because I can actually close a loop and be done. So I do a task, I finish it, then I switch focus instead of being in the middle of a multi-day task where I have to switch focus away in the middle of the task and then I have to reload all the context back in. So that having that completion in there is what's really powerful for me personally. Yeah, that's a good point. I like that term you used, reload the context, but you're talking about your brain. Yes, yes, I'm loading context into my brain. That reminds me of another thing that I think I was kind of curious to get your experience on and I can share a little bit about mine as well is...

I do think that I found myself juggling individual pieces. Maybe if I realized, oh, like there is something that needs to happen first and wanting to pull that into its own PR. I'd already kind of gone down the path before I'd realized that. And like, maybe I have a branch or a PR already for that work and being like, okay, like now I want to pull out like these commits, have them on a separate branch. At the end of the day, like a few of the things that that really helped me with was feel more confidence in the changes. I was specifically like when I would ship them, I was like, cool. I have, there's just less of a footprint to worry about, especially if you do feel a little bit nervous about how releasing will go.

But that also meant I had to be extra diligent about just remembering what steps I needed to take, just where the path was kind of moving forward because I was finding all these steps. I don't know. For some reason, I'm imagining just discovering more steps on the path as you're going and having to remember where that, what direction you're going in. Do you have any anecdotal experience or thoughts about managing that? One thing that is nice for me about working in smaller incremental pieces is that a thing that I've had to learn is the discipline to stay really focused on the task at hand.

And so oftentimes along the way, there are little discoveries. Oh, there's a little bug here. There's a thing I could refactor there. And it's really tempting to just fold it into your changes. While I'm here, I may as well do some unrelated changes. And that will make your change larger. It might make your PR larger. It definitely means that your code is now doing multiple things. And I've found that I have to have that discipline to stay on the path and to find all these little things that I'm doing. If I want to do them now, fine, but just do them another commit and put them on another branch, or maybe it's a separate commit that I will then pull out some other way, but keeping it separate from the work that I'm doing so that I do stay on that path. I'm just sort of...

one thing after another, because otherwise it is easy to get sort of distracted. I kind of want to go back to the idea of incentives and de-incentives. Have you experienced times when it's harder to do that for some reason or another about the kind of project you're working on or team you're working with? Anything that lengthens the sort of software development lifecycle tends to de-incentivize that. So I've been on projects where code can't be merged until it's gone through QA, and QA was a team at a time zone on the other side of the world, which basically meant that the fastest you could have turned around on getting a ticket and building it, shipping it was 24 hours, which meant that you were then much more likely to bundle a bunch of things together so they could go over and get that QA approval. And so something like that slows down the whole process and makes it much less likely for you to want to chunk things up. Another thing that I've seen that's a little bit maybe more common is really long CI times. If it takes forever to get code reviewed, and if there is starting to be like a bottleneck, because everybody's code is taking a long time to get reviewed on CI, then maybe at peak moments when everybody on the team is pushing up branches, your CI runner can't even like handle everything. So it might even be like a backlog or a queue of something to get processed.

Now you're not going to want to put two branches up for review into that CIQ. You're going to try to combo things together. And so things like that have, they lengthen every step of your software development lifecycle, but they also incentivize you to cram as much as possible into one go through. Yeah, I have a lot of thoughts in response to what you said. Because, you know, at first we did talk a little bit about the idea of discipline, right? But at the same time, I think that breaks down when there are all of those barriers or like all just a lot of friction in your software development lifecycle. And so sometimes I hear, I don't know, like teams want to work iteratively.

and ship fast, but don't really address that there are the parts that are taking long in that life cycle. Maybe they just point to things that aren't quite... You can say however many times you want, like, oh, we want our developers to chuck up their work. But if the things are not in place to encourage people to chuck up their work, then I don't really know how effective that will end up being. Yeah, you can pour a lot of energy into trying to make something like that happen, but then you have all of this sort of negative energy pulling you back. Have you encountered anything that has been sort of the opposite? Not a break on your attempts to...

iterate faster, but something that's actually been an accelerator for you. Yeah. I don't know if it, I guess accelerator can mean a couple of different things here, but one of the other benefits that I've been seeing that kind of contribute to the virtuous cycle, I suppose, is when I am working that way, I also can communicate more clearly and more frequently about what's taking so long, right? When you discover like, oh, it turns out there is this other step that it would be really good for that to happen first. You can say, I need to refactor this class. Otherwise I can't move on to the next step as opposed to kind of giving that same update, like, oh, I'm still working on this.

And I have gotten positive feedback that those kinds of updates are helpful. And just being able to own that a little bit more for myself and just saying, yeah, I've broken this down into these chunks and I will be able to get this chunk done. I do think some amount of it has been a change in my own workflow to be able to communicate better. I had to know why I was taking longer than I had initially said I was going to take. And figuring that out for myself makes it easier for other people to also see it.

I think that's a really sort of undersung value of working iteratively because I've definitely felt that that has dramatically improved my communication with the broader team about what I'm working on, especially for work that goes on over multiple days. And like every day just being like, I'm still working on the thing. At some point, like, what am I actually working on? Whereas having more specific things and also having the team having seen, hey, I've been like shipping, putting code up for review once or twice a day where people are being able to see what has been done. And now they know, okay, I'm on this next step and that's the thing I'm working on today and that will be up for review and then that will go out and then we're working on the next step. It's also really good for...

Myself personally, I think I feel better about myself when I'm consistently shipping rather than just moving code around on my local machine for days at a time. I get the feeling of velocity and probably some actual velocity as well. But I definitely get the feeling of it, which is then translate probably into me working more effectively because I'm feeling really good about myself. Nice. Yeah, I like that. I'm curious for you, what is your sort of preferred cadence? Clearly, you don't want to be working on a feature for two weeks and not ship anything. What would be sort of your preferred shipping rate? Oh, that's an interesting question.

I think lately I've been able to move on average. I think it does end up being about like a PR a day. And when you were talking about velocity, it's not just the number of PRs, right? Because you could just, I don't know why this came up, but the idea that like you can just undo the change and then redo it over and over again and look like you're moving back or like look like you're doing a lot. But the meat of the work I do think has been like.

making progress. Whereas sometimes, I mean, I was joking about the like undoing the change, but sometimes, you know, you do find yourself shipping a big thing and then having to revert it right after. And then you're kind of where you started as opposed to at least being somewhere else. So I don't know. I think a PR a day feels reasonable for me, at least lately on the work I'm doing. That's about where I like it as well. You know, there are some projects where there are things, especially on a newer kind of greenfield project where you have a bunch of little tasks and you're maybe shipping a bunch a day and that's really feeling good. I usually sort of try not to go beyond a day if there's work that I'm working on.

spans multiple days, that's to me usually a big sign that it needs to be split up. Have you ever gotten into the problem where you're thinking too far ahead? Or I think that's another thing that I've been experiencing a little bit where I'm almost like anticipating the next chunks of work that I'm going to have to do when really I should be a bit more laser focused on what I'm trying to complete now. I've definitely felt that. And I think something that has taught me to not think too far ahead has been TDD. Now, I don't test drive everything that I do, but I think having done a lot of test-driven development, TDD wants you to write the minimum amount of code that it takes to make the test go green.

Very often, there's all these grand designs kind of noodling in the back of my head, or I'm thinking two or three steps ahead when I really don't need to for the test that I'm trying to make pass. And so TDD has sort of forced me at various points of my development career to step back and be a little bit more focused on the present and doing the things that need to happen now for this incremental work before trying to sort of like think 10 steps ahead. Ooh, okay. That actually got me thinking about the idea of good enough code. And I think this is another potential incentive or de-incentive depending on how your team handles it. But when you are working in iterations, one of the benefits I think is that you are coming back to it frequently and it doesn't need to be perfect because you know that you'll come back to it. And I think that mindset, like sometimes things get kind of hung up perhaps in review when people are really pushing maybe for that perfect design or like.

really wanting to address all of the problems while you happen to be in this file. So could we also fix all these other things? Whereas I do think if the consensus is that we want to be making improvements as we iterate where it's reasonable, it will get there eventually. The point isn't for it all to happen in a single PR. And so I think that kind of shift in mindset can also affect the type of feedback you're getting, the length, and just the cycle of the kind of communications you're having in each iteration.

Yeah, that's the beauty of agility in general. You're not locked into a lot of your choices as much because you've made it really easy to change and come back to them. The cost of making a technical decision and then coming back and changing it a couple days later is very low. Yeah, and I think that I can't think of reasons why those costs end up feeling high, but I've definitely been on teams where that cost does feel high. Even if it's not true, right? Even if it's not reality, there is maybe a felt sense that we can't go back to them. Maybe it's because there's a history of not being able to iterate on a feature, right? And this idea that...

we just move on from it and start on something new. So yeah, definitely curious about how that encourages or discourages that working iteratively in practice. The thing that I found myself doing is with almost like architecture design, if I'm sort of building a base feature and I know there's other things that will come, I want to make it modular because I know things will build on it, but it's really tempting to try to build a grand system and saying, no, look, the only thing that this thing needs to do in order for me to shift this feature is for the ability to display a message in plain text. Yeah, I want to eventually be able to like have the super modular and handle all sorts of formats and things like that. But as of today, the thing I need to ship today only needs plain text. Forget all the other stuff. And so you ship something minimalist and then you iterate on it and you refactor. And it's a little bit like TDD, but on a grander scale. Yeah, that makes me think about how your organization also probably needs to be comfortable with like some minimalism. That reminded me of just, I guess, another.

It's like an exercise in working iteratively. I have mentioned it before, the Elephant Carpaccio exercise, where you are asked to take a feature and break it down in as tiny increments as possible. And usually it's like an exercise facilitated by someone. And part of that workshop involves people, encouraging people to even just get like, hello world to show up, like you said, in plain text, right? And that is not nothing, even if the goal was to like build a shopping cart or something.

I've definitely done something like that, especially for Greenfield apps where we're developing something and we're building some kind of SaaS product for a startup founder. But the first commit might just be, okay, we generate a Rails app and there's a homepage that just says, hello, name of product. And that's the thing that you can then ship and put up on a staging site. And hey, there's nothing here that's a shell of a website, but you have an app up and this has been hour one of us developing this product, which is a really great feel. for someone who's just started working with us and being able to start seeing results that fast. But it's also great for the team as well to then say, hey, we have something up and now we can start building on top of it. I think I don't tend to do that quite as much for like, if I'm plugging in a shopping cart into an existing piece of code, I'm not going to add just a bit of text that says hello world in the top right corner of your website and ship that out to production. That's not helpful. I think one of the important...

pieces of the elephant carpaccio exercise you mentioned is that it has to actually deliver value to users. And so the textile world in the corner is probably not helpful for a shopping cart, but there's probably a minimal version of that that you could do and ship out that would. Yeah, I do like the idea that that value is relative and it would be beneficial to think about like what that means at different scales. One thing that I do kind of like is, for example, like you could have done that behind a feature flag and in that way you are working iteratively shipping while also knowing that you're not. releasing something that, I don't know, in that situation, I almost think it would be not valuable because people would be confused. But there are also other kind of mechanisms that can encourage working that way, even if you're kind of past the point of having a greenfield project. I have one more kind of topic within this topic, subtopic, and I'm not totally sure how to phrase it, but there's something to the idea of as things are changing in iterations, like keeping up with those changes as they evolve, sometimes I think it can be challenging. And I don't, again, like not to say that that waterfall style.

is how I like to be working. But I do think one of the challenges that I have is not having those boundaries around when some things have changed with the future. And I'm curious if you have any thoughts about just managing that kind of mental model of things because they're changing so quickly. Are you thinking more in terms of a developer and the features that you're being asked to implement are changing out from under you? Or maybe like a reviewer who's seeing different iterations of the code being sent to you for PR, and then that seems very different than the last time you looked at it? The latter, yeah, as a reviewer.

I'm thinking about the idea of change sets. And in some ways, those can be easy to consume all at once and be like, okay, now I know the state of the system post these changes, as opposed to when things are happening at less step-like increments. Sometimes, yeah, when you're reviewing a thing and then you come back a week later and you're being asked to review something else, it's like, oh, this architecture feels very different than the last time I reviewed it. And that might lead to some conversations. And hey, well, in between the two, we discovered this new requirement or this new technical roadblock that caused us to change course with our technical architecture.

And maybe as a reviewer, I would be less confused if I just saw the final project and saw maybe it is a thousand lines of diff, but I don't have to sort of go through the different attempts that were made and only see the final thing. Maybe that's easier for me as a reviewer, but it comes at the cost of having to review a thousand lines of diff. Yeah. And actually, I also think that there is some value in seeing the evolution as well, because you see what didn't work and you then add that to your kind of bank of knowledge. And I do think that can just be important later, you know, when you want to try something.

That kind of reminded you, like, oh, we did already try this, and it didn't work for this reason. And so that experience, I think, can be helpful, even if it just leads to not investing time in a certain approach. So kind of seeing the in-between things, I think, help with that as opposed to just kind of seeing the before and after. Just less, just different kinds of information or knowledge transfer. It probably allows also for more involvement from the team in particularly, like, learning technical.

decisions where instead of one or two people going off for two weeks and building a big feature and then asking for review on it and other team members being like oh those are some interesting technical choices why did you do x or did you consider y and maybe you considered y but like that is lost to time people don't know about that unless you explained it in your commit message or maybe you haven't and now somebody says that you've got to go all the way back to the drawing board because yeah why is a better idea i guess it's maybe a little bit more like a sunk cost there sometimes where sometimes now like at review time a better approach comes out but you've already invested so much in your current approach so complex that it's not the best, but it's good enough and it's not worth going back with the alternative solution. Yeah, that's real. I like that. I'm just kind of processing it right now where there is more opportunity to change course. And I think that is generally good. And there's more opportunity to involve the team in that changing of that course. Obviously, you don't want like five or 10 backseat drivers on you the entire time telling you to change what you're building. But if you are in an area where you've hit a roadblock or things are technically challenging, it's a way to have people come in earlier in the process.

And you could do that in some other ways by pair programming, by asking for help, but by having other eyes on your code more frequently, sort of consistently throughout the development of a larger feature. I think that benefits everyone. Yeah, I definitely agree with that. I never, I didn't think about how the virtuous cycle of working iteratively does kind of lead to that as a byproduct as well. So that actually is a really compelling reason for me personally.

I hadn't really thought of it either until you asked the question. I was like, huh, what is it like to just see a ton of changes at the end versus be involved, sort of interleaved in the process throughout? And I think I like the, as a reviewer, being more interleaved in than parachuting at the end. Yeah, definitely. On that note, shall we wrap up? Let's wrap up.

Show notes for this episode can be found at bikeshed.thoughtbot.com. If you enjoyed listening, one really easy way to support the show is to leave us a quick rating or even a review in iTunes. It really helps other folks find the show. If you have any feedback or questions, you can reach us at hosts at bikeshed.fm via email. Thank you so much for listening to The Bike Shed, and we'll see you next week. Bye!

Frequently asked questions

How long is this episode of The Bike Shed?

This episode is 40 minutes long.

When was this The Bike Shed episode published?

This episode was published on October 29, 2024.

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.