Skip to content
462: Decomposition as a key developer skill with Steve Polito episode artwork

May 6, 2025 42 min

462: Decomposition as a key developer skill with Steve Polito

from The Bike Shed Hosted by thoughtbot

Joël and Steve sit down to discuss the ins and outs of decomposition within their respective workflows and how they use it to their advantage when working on certain projects. Together they look at working with vertical slices over other decomposition methods, when and how to break down code as efficiently as possible, and Joël lays out his three key principles that help him write code dubbed “The Triangle of Separation”. — The Sponsor for this episode has been Judoscale - Autoscale the Right Way. Check out the link for your free gift! Learn more about Joël’s triangle of separation and working with vertical slices! Your guest this week has been Steve Polito, and your host for this episode has been thoughtbot’s own Joël Quenneville. You can find Steve’s work over on GitHub, or dive into more of his thought processes over on his thoughtbot’s blogs. 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. — Credit: Ad-read music by joystock.org

Episode details come from the podcast's RSS feed.

Embed this episode

Ready to play

462: Decomposition as a key developer skill with Steve Polito

0:00 42:18
of matches

Transcript Auto-generated, may contain errors

Imagine the last time you had to deal with request timeouts, or back up job queues in your job environment. Take yourself there. Can you feel it? The stress, the frustration? Here's what Judo Scales knows. You're either not auto-scaling, or your auto-scaler is not doing its job.

Because auto-scaling is supposed to prevent scenarios like this. In comes Judo-scale. Judo-scale helps your app smoothly handle traffic spikes while dramatically lowering your hosting costs. You can use Judo-scale's free plan forever, so you've got nothing to lose. If you want to say goodbye to those painful production incidents, visit judoscale.com.

For your special gift is a bike-shid listener. That's judoscale.com slash bike-shid. Hello, and welcome to another episode of the Bike-shid, a weekly podcast from your friends at ThoughtBot about developing great software. I'm Joel Kinville, and today I'm joined by ThoughtBot colleague Steve Polito. Hey everyone, hey Joel, thanks for having me on.

Together we're here to share a bit of what we've learned along the way. So Steve, what's new in your world? Hey, all right, so a little fun fact that I learned recently. So I'm in Mansfield, Massachusetts, and there's a commuter-real station here. And apparently it's one of two places, and maybe America, we'll just say that.

One of two places in America where the Assella can go its top speed by platform, which is roughly 150 miles an hour. And I can confirm that it is incredible and that happens in also very frightening. So if you haven't heard of Mansfield, Massachusetts, before, that's going to put it on the map for you right there. So if you're a big train enthusiast, check it out. I don't think it'll be disappointed.

And for those who aren't familiar, the Assella is the four of the US considered high speed rail sort of mainline connection that runs between New York and Boston and beyond. Exactly, yeah. So I don't know if that's a good thing or not for Mansfield. I don't know if it's like, we just got to get out of here. Like, let's keep it moving, folks. But I've been on the platform before when I think it's really cool, but also terrifying.

It blows off your hat. Yeah, it blows off your hat and anything else that isn't strapped down. It's just like the cartoons. Exactly, yeah. So, yeah, it's a little fun fact.

But other than that, just enjoying the nice weather appeared, it's spring, so things are starting to get warmer, get nicer. What about you? What's new in your world? I've wrapped up a conference season where there's been a lot of abstracts to calls for proposal. And I got a chance to try something a little bit different this year.

Repeat Listeners of the show will have heard me talk about my note-taking system, where I take down ideas as a series of atomic notes. Each note is the title is a thesis statement, something I think is true about software, and there's a paragraph of supporting information. And these notes hyperlink to each other. And what I did this year is I took the themes that a conference was looking for. And a list of all of the theses in my note-taking system, dropped them all into an AI, and asked it to find talk ideas that would fit within the theme of the conference, based off of where I had multiple notes in my note-taking system that could act as a basis of it.

Nice. It didn't work out as you would expect. It worked decently well. Some of them were ideas where I already had that as an idea. Kudos to the AI for finding that, but I'd already found it on my own.

Some of them were ones I hadn't thought about, but while digging into them, I realized, wait, I wrote a blog post version of this. I had to go into something. I had considered it as a talk idea. There's already a blog post out, so I could absolutely take that blog post as the skeleton for a great talk. And then there's a few that I think it didn't quite understand what my note was about.

And so it made some inferences between some notes and then tied them to a topic in a way that I don't want to quite say it's hallucinating, but it's connecting things that don't really make sense. And I think it would do a better job if I'd fed it the full context of the note rather than just dropping titles. Yeah, that's cool. It was just like a JPT type interface, like just the chat interface. So no complicated API stuff, just copy-based.

Nothing like that. Cool. I'm really intrigued with the possibility of using an AI to interact with my notes because I've built up a lot of interesting ideas in there. And there's various ways I can search and query the notes. This visual graphs that can generate from them that are helpful to understand.

But I think there's a lot of knowledge and intuition that's maybe locked away in there that I can access more easily via some kind of AI chat interface. Yeah, that'd be cool. I wonder if there would be a way for it to maybe also help you come up with the idea. I'd also help you come up with like probably find friends and maybe also help you like think of a topic you haven't even thought about yet that you might be thinking about. It's interesting. I like exploring ideas like that through AI.

Yeah, yeah. I'd be really curious to see what I can get out of connecting to my notes. And I don't want the AI to write my notes because I think that's where I get a lot of value. Distilling my thoughts, breaking them down into individual theses, writing out a paragraph of prose. That's stuff that's useful for me to do. But there's other things such as maybe I've written a new note and I'm trying to think,

what are some ideas that are relevant that are already in my note taking system that would make sense to blink? I will sort of scan through manually, do a couple searches on some keywords to see, are there any existing ideas that we want to link to this? But I'd love to see an AI sort of suggested notes to link or something like that. Notes that are on similar topics. Or maybe even that have an interesting connection, but I would never have thought of it.

That seems like it could be really powerful. Yeah, absolutely. I agree with that. I feel like a thing that I really value doing as part of this note taking system is breaking down larger ideas into smaller sort of atomic ideas. And that's helpful for the notes. I like having them broken down atomically.

But I think that it's actually something that we do sort of every day as developers. And I don't know, maybe if there's one skill that I feel like every developer should get really good at, it's decompositioning. And I think that could apply to a lot of different aspects of our dev life. We can take that from a few different angles. I think maybe the first angle we could look at is looking at an epic or a story ticket and figuring out how to break that work up into smaller pieces.

Or to decouple it, which it's a learned skill that I feel like I kind of struggled with when I first started out doing software. Because it doesn't really have a whole lot to do with coding depending on what it is or it has to do. And if you don't take that time to kind of break it down and instead jump right into the code, you might miss the solution. And I can kind of talk more about that with some concrete examples, but I want to hear how that resonates with you. Yeah, I think definitely at a sort of product level, learning to break down larger sets of features into sort of individually shipable pieces is a really important thing.

There's a little bit of overlap, some of that is often done by project managers, but I think that as developers, that's a skill that we need as well. What do you think was helpful for you in terms of leveling up that skill? I think honestly, one of the things that highlighted it for me was the interview here at Notlaw because there was a question along those lines, which was like, how would you break this up? And I honestly, I'm pretty sure my answer was like the naive answer, but the question was, I was thinking about it almost like in terms of horizontal slices, so I was like, okay, you know, you could work on the model in one PR and work on the controller, another PR, the view of another PR. And that is one way to break up the work, but it's not going to result in necessarily the most effective way to ship it because you're going to most likely be shipping dead code.

This is something that's been mentioned on the podcast a lot, which has actually helped me. So if you just work on the model separately, cool, that's great, but like, there's no interface for someone to interact with that model, whether it's an API or like actually like a browser, right? You're not delivering value? No, no, and not only that, but if you work in a vertical slice, that's kind of what I've always referred to them as like vertical slice meaning like what is a feature that doesn't introduce dead code and is something that introduces new behavior that can be interacted with, whether it's like, you know, again, through like the web browser or an API or something like that, you try to work on thinking about it in terms of what behavior you're going to introduce.

I've added to one of two things. You have a much more informed way of building it because you're not building it in isolation. So that's the horizontal slices that I just mentioned, right? Like if you build model in isolation, you aren't being informed by how the user might be filling out the form to create that record in the database. And then you might end up getting it wrong and have to go back and change that code after it's already been shipped.

Whereas if you work on a vertical slice, you're going to be informed by the actual behavior the user is going to be using to help you shape your, not only your model, but your controllers or anything else in between. And once I understood that concept, it was helpful for me breaking down work. So that way I basically knew when I was given the task, I knew one, let's make sure it's providing value like someone can actually interact with this when it ships. And then from there, I would think, okay, well, what's the, you know, the thinnest vertical slice I can ship here because otherwise this PR is going to be sitting around for days, if not weeks, because it's too big.

And that was something I kind of struggled with once I had this realization of vertical slices was how to break it down more. Right, because there's two elements to this, right? There's a sort of product level concern of we want to be sort of continuously shipping value to customers. And then there's a code level concern that if you've got a thousand line PR, that just really gums up the review process. It takes a long time and you're probably going to get lower quality review on it.

Absolutely. You know, I think about situations where you need to review if you're the too, yeah, it's challenging to review it. And yeah, sometimes the quality of that review isn't great because it's just too overwhelming. Are there some tricks that you've learned along the way to either help scope your stories more tightly or to break down code so that it's smaller in your PRs? Yeah, there's a few. One is just speaking to the stakeholder in getting clarification on things because it's possible, I try to look at things in terms of like what is the outcome in terms of behavior.

And just because a story is written in a particular way, doesn't mean it has to be that way. I think that is something that is often overlooked, right? Just because you are assigned a ticket doesn't mean you need to just take it at base value. You can always change it. You can always talk to the stakeholder.

So that's one thing that could help you break it down, right? Because maybe the requirements don't need to be as strict. Another thing is understanding if the code isn't even going to be, maybe it's behind a feature flag or something, right? So I know we talked about like, I've been mentioning like, okay, let's get this in front of a user, but sometimes you can get away with having it behind a feature flag, but it still is a vertical slice, right? Like everything that went into it was informed by like user behavior, but you can ship it safely so that it's not necessarily in front of a user.

And that way you can kind of like iterate over it. So a very like, contrap example is just to say we're making a blog, right? And it's like, we could ship the whole thing, right? Where it's like, there's a form with a title, description, and tags, and that's all well and good, but if it was behind a feature flag or something, or even not behind a feature flag, right? You could maybe do, okay, let's just do title and body first, right?

Like that's in a stakeholder is good, but that's fine. And then on the next pass, you can add a tagging system. And maybe on the next pass, you could add some type of commenting system. I guess it's like a front end feature that's going to be on a browser. I try to think about it in terms of like what are the fields on a form or what is the data that's going to be displayed and is appropriate to remove some of that or like, what's the least amount of information that I can get on the page that adds value such that the commit is small so that it will be reviewed quicker and shipped quicker.

Yeah, my thinking about in terms of like the UI and having it be functional, that force you to think about everything full stack because shipping some new fields on a form that aren't wired to anything is now your breaking user experience. That's not acceptable. So what do you need to do to wire up that one form field or two form fields in order to add and improve the experience. So you probably need to make some changes to a controller. You might need to make a change to your database. You might need to wire some other things up by thinking about from the user's perspective, adding that new behavior.

What's the minimum where it's actually useful? And I like starting from the UI and working back. That's a great tip. Yeah, I can give a concrete example from something I just did a few weeks ago, but we were displaying some data on a dashboard and the final deliverable was going to be, you know, here's a number in this case, it was going to be paid time off. So here's a number. You can click it and then a modal would appear and it would give each line item of like, how do we get to this number? Right.

And there's a few ways that can be simplified. So the first could be speaking to a stakeholder and saying, is it acceptable to just render the final calculated value? And then the subsequent PR we can add the line items and depending on requirements, maybe it's not acceptable. Maybe it's really important that people see how do we get to that number. But that's, you know, that's one way to simplify it.

Another is if everything needs to be displayed, you could also say, hey, do we need a modal right now? Or could we just show the calculated value in the line items? I'll just kind of smack that on the page without a modal component and then, you know, and a subsequent PR increase the fidelity. So that's another way to as an aside, every time I see a modal in a comp, I'm always like, man, like, can we just put this on the page normal and then deal with the modal later? Uh huh. It always adds just enough friction where I'm like, man, you know, that's my, that's like the most concrete example I can give is personally, when C.

I'm trying to cut the modal and I'm trying to cut scope. That's usually the first thing I want to go is just, can we just render this on the page, not in a modal, please? You can try that. That's my, that's my quick tip. I've had conversations with Op-out designers where they've been very skeptical of sort of the proliferation of modals now that they never have the place, but they're sort of very often overused design element in terms of UI.

And then they can often be a crutch. Now I feel like I should probably have one of them on to the show and like explore this topic in more detail because I think that's something that maybe you build intuition for is a really sort of experience to do. And then I think that's a really good idea. That's not obvious to everyone else. And so everybody else just throws a modal at every problem and we complicate our lives unnecessarily.

Right. Yeah. And in this case, I mean, I think it was acceptable to have the modal in this context, but yeah, that's just one way to kind of simplify the work such that it can be shipped quicker. I think there's another element here as well, which is especially on projects a little bit more startupy where you're really trying to move fast and the opportunity cost of like spending a lot of time on one feature can be relatively high because you're losing the opportunity to do a different feature. You can iterate faster, but you can also then cut scope if any of the sort of follow up things end up being harder than you think.

So sort of like you were saying for that, like breaking down the line items. Maybe that summary is good enough. And after some initial like that goes live immediately because that's a short task to do. And then based on feedback from users and talk of the product team, they realize, you know what, the sort of breakdown while nice doesn't provide that much value yet, we would like to prioritize other features and those get to bubble up to the top. Whereas if everything was in a package, now you're just committing to everything and you need at least the summary. That's a non negotiable, but you're having to invest instead of one day to get the summary.

Now you're doing a week to get the summary plus the breakdown that leads to sort of some optimal outcome. So I've been more granular with your stories in vertical slices. You get more flexibility for restructuring priority. Exactly. Yeah. The restructuring priority is a great benefit of that. It also means if that feature, especially in kind of like the startup world where you're just trying to show quickly, maybe that feature isn't even valuable to begin with.

You don't know until you actually ship it. And this is kind of something we were saying, but imagine if you spent like two weeks on this dashboard and like turned the metrics tell you that like, well, no one's looking at this page. Right. It's a lot better to find that out quickly versus, you know, spending one or two sprints on it to find out how this was kind of a wasted effort. Right. So now I think we're talking about working in an sort of iterative fashion.

And what a lot of sort of agile or lean startupy places will tell you is you want to reduce the length of those cycles, the tighter that feedback cycle, the faster you can respond to change the more agile you can be. Yeah, absolutely. So we've been thinking a lot about decomposition at a sort of product and feature level. I think a zoom in a little bit more into code itself because I feel like there's a lot of like writing good code that involves decomposition. I'm talking about composition in code, right, composing objects, composing functions, which is great when you're sort of putting together existing behavior, but someone has to build those components first and has to think about what are the parts that are reusable, where are the like teams where you can break apart that code. That's decomposition. How do you get good at that? Yeah, that's something I'm still working on. It's kind of a process. I mean, if I'm my discipline is rails. So typically I just try to rely on conventions as much as I can. So I don't even have to think about it.

There are patterns in the community that are sort of well established and give you some pretty obvious places to break down complexity. Exactly. Yeah. So, you know, I'm always going to try to stick to rails conventions. I also try to strike a balance between I don't want to abstract anything too early because, you know, I'm not going to have to do that.

Because, you know, the wrong abstraction can always be worse than no abstraction at all. So I try to keep that in my back pocket too. And especially, you know, kind of it does go back to that iterative cycle in a way from a product standpoint, where if you're trying to get a feature in front of users quickly, you're going to be relying on the feedback of those users. And so for starters, one, maybe the feature isn't that valuable turns out. So it might be OK if you didn't abstract away the logic into like a class or something.

Maybe everything is just procedural in a controller for the time being. But then that file never really gets changed because it wasn't actually valuable and that feature was just deprecated. If there's a lot of churn in that file or files, then that's usually like, OK, we should probably think about, you know, decoupling this a bit because now it's getting a little out of control. Are there ways that you can use churn to help find the themes of where you should sort of make a boundary between two concepts? Yeah. Is there an answer to that? Is there? I'm sure there's probably some command line tools you can run to see which files have the most churn, right?

Yeah. I haven't actually done that yet. Yeah. I think a classic one is a complexity versus churn. OK.

And so you find files that have high complexity and high churn and that gives you a file that you can then break apart. But sometimes finding up like it's all tangled together. How do you figure out what to break apart from that sort of high value file? Yeah, that's a great question. I mean, I guess if there is some duplication across the application, right?

So if you happen to notice similar business logic being applied multiple places that hasn't been extracted yet, that's a good case to extract that into like a service object or something like that. I guess it would depend on the responsibility of what that code is doing. Like if it's asynchronous or not, I think that's one way to determine where it could go, right? Like should this stuff live in a job or not? That's one way to look at it. Another is like, is this just presentational?

If it's presentational, there's other ways we can handle that. I think those are kind of some starting points. So looking at sort of patterns of either responsibilities or usage and sort of cluster around that or use those is almost imagining you have like a junk drawer of stuff and you're just sort of putting two or three big magnets around the edges for different things and just sort of pulling things towards one magnet or another based off responsibilities or. Access that kind of thing. Yeah, exactly. I like that. That's a good visual. I like that. And I mean, for me personally, I would, if it's like a new project without too many patterns yet, I would just try to rely on our thought block guidance and also the rails guidance.

If it's an established project that already has its own conventions, you know, I would just lean into whatever those may be. I had a thought the other day when I was thinking about the idea of decomposition and when you're decomposing tickets or even sort of commits, we often talk about trying to break things down to sort of atomic level where it doesn't really make sense to break down further. So an atomic story is sort of that thinnest vertical slice atomic commit is sort of a commit where I guess you could have this is a controversy around what is an atomic commit. I tend to define it as the smallest amount of code that adds value is not dead and like passes CI is deployable. What is an atomic unit of code when you're doing decomposition? Right, you've got a file that's a junk drawer.

What is the sort of atomic level where you can't really break it down further? This is the smallest piece of something that can stand on its own. I mean, the first thing that comes to mind is like a method or maybe even like a constant, but that by itself doesn't really add, I mean, I guess we're talking about atomic code, right? So I guess by itself, it is just a small thing. It's just one line. So yeah, I don't know.

I think my knee jerk reaction would be something like a constant or variable that may be like a molecule would be a method. And then from there, a class might be an organism. I'm like mixing names here, but you get what I'm saying. The whole being, I guess itself would be the application. But yeah, I think final answer constants are small or maybe prima, but then it's primitives too, right? But that's, I guess, a different thing altogether.

I'm curious what you think though. I trust you given this more thought that I have. I want to hear what you have to say about this. My sort of go to, I think, is thinking a method or function if you're in a functional language. I think a constant or variable is probably also a good choice.

Those tend to be more static though. So maybe this sort of atomic piece of data is a variable that an atomic piece of behavior is a method. But I think it's important though, it's a thing with a name. Because the thing with a name can be composed with other things because you have something to reference it with. Whereas something that doesn't, you don't have a way to reference it. So I imagine complex code, right? And you've got a conditional with a bunch of different branches.

Somewhere else wants to reuse the behavior in one of the branches of that conditional. You can't do that. You can't just say, Hey, I want this branch of conditional. And sort of older school code that has a go to command, right? You can go to and jump to particular lines. But that's at that point you're effectively creating your own sort of conditional logic.

But in a language like Ruby or JavaScript, you can't just reference a particular line in a conditional. If you want to do that, what you have to do is you have to extract that behavior from the conditional into a standalone method or function. Reference that from the conditional and then other places can also reference it. And so I'm thinking in terms of like I've got complex code and I want to break it into smaller chunks that can be remixed. I think your initial reaction of it's a method or a function is probably the correct one.

Yeah, I'm with you on that. I'm with you on that. And that's something with the name that has behavior. It's a great way to look at it. And I think that maybe helps explain. I have a series of heuristics that I use for breaking down code into smaller pieces that I call the triangle of separation.

So three principles that say, right code is single level of abstraction, separate branching code from doing code and push conditionals up the decision tree. And when you dig into all of those, what they all sort of push you towards doing is pulling logic out into smaller functions that can then be composed back together. So if I give an example from the first one or the one about separating branching code from doing code that says that a method or function that has conditional in it. So if else doesn't get to have both the conditional logic and the implementation. So if you have an else, the only thing you can do from an if else is call another function.

If a function has actual logic, do this thing, do this thing or calculate this thing, I can't have conditions in it. So functions either branching or they're doing, they don't do both. And what that does is basically every time you encounter a conditional in your algorithm, it forces you to split out functions. So now you have a bunch of little pieces that can be composed together. And part of the reason that's valuable is that wanting to have access to a branch of conditional is a thing that you end up wanting to do more often than you think.

And so having a sort of pre made already usable as a function is really convenient. Yeah, I like that. I'm curious what, because I'm with you with those heuristics like those resonate with me. What led you to those was it just experienced over time? Was there an aha moment or was it just after like a decade you look back and you're like, oh yeah, this is kind of where I've been, I've been going towards this path for a while now and I've probably been here for a while and just didn't realize it.

It was a little bit of both, but there was definitely an aha moment that came while I was doing a lot of elm and elm has this concept of a maybe type, the value that is potentially null. And every time you want to access a value that's potentially null, elms compiler will force you to make a null check. And that gets really annoying as you're passing a nullable value throughout a system and having to do a null check all the way down the line gets really clunky. And so what you end up doing is you tend to either not do anything to it and just sort of pass it all the way down the line and then unwrap it at the end check whether it's null or not. Or you'll unwrap at the beginning and have a branch for if the values null and then you just sort in there and you have a continuing branch for things that are for the path that's not not nullable.

And the way that elm does is that it provides a way to just say, run this function on this value if it's present. And so what you end up doing that function really what it's doing is abstracting away the conditional that if null do nothing otherwise do this thing. And the actual behavior that should only care only execute if the values present that you create a separate function for. And so I was exploring patterns around how that worked. And the idea of separating your business logic that doesn't need to know whether a value is nullable or not just say assuming the values present here's the business logic I want to run.

So all of your business logic functions are written in a very confident style because they can assume in fact the compiler guarantees that they're present. And then the nulls and the presence check all gets done sort of separately that's a separation of logic right there. And so then I started wondering are there other places you can start doing that and I started expanding that other forms of uncertainty and then sort of realizing wait this is just if I strip away all the syntax from the language all this is doing is separating code that does conditionals from code that does business logic and the business logic functions don't do conditionals they just do their business logic assuming that they're on the right path and it's up to you to compose them later. So it's a very compositional approach that elm has that wasn't aha moment for me.

Thank you for walking me through that and I've benefited from your your learning just by listening to this podcast because I've heard these and read these several times. Even though we don't always work together on projects you're kind of working with me without realizing it because I'll think okay you know I'm coming to a fourth of the road which I do you should I have to break this down and I come back to those heuristics so thank you for that. Are there any sort of heuristics or refactoring patterns that you're particularly fond of? I think it depends on the project I'm on in terms of like I'll try to do whatever the project is doing. That's my general characteristic is like I want to introduce a different way of doing something on a project and joining unless I think there's a good reason to use that approach.

Yeah I don't know I mean the things that you mentioned I try to do I'm always kind of caught between like how small can I make this diff because then it'll just probably pass code review much quicker. So that's one thing I like to do but then I also struggle because I'm like well you know hey that's sure this is like a two line change and it's super easy to read but is there an opportunity to perfect for this and like maybe follow a better pattern and that's something I kind of struggle with I never know the answer because the abstraction could take an extra day or two and it may not add any immediate value right away especially kind of to go back to the churn discussion the thing I'm working on has very low churn and low complexity so it probably wouldn't benefit from being distracted especially for just trying to iterate through things.

But yeah I mean in general I like to keep commits very small this isn't so much a coding characteristic but I just always try to explain the why and not the what in my commit messages. I love that. Yeah and the best is when the ratio is like a hundred to one so like you have a one line diff but you know the PR description is like a short story. Those are always fun right because it's like wow this is a significant change what's going on here. I like when that happens.

I feel like commonly for me those have been like really tricky bugs where I spent like a full day just hunting down the bug and so the commit message might have that whole story of the journey I went on that day but then also maybe some of the testing things I ran that proves that this is in fact the source of the bug or they explain like why this like sort of random config change here actually is the cause of the bugs are like laying out the chain of evidence. For me that's commonly one line change and paragraphs of text and the message it's going to be a bug fix. Exactly yeah and that's what you want to really add as much detail as possible. If nothing else it'll just benefit you like two weeks later when you're like why don't I do this again because I always forget why I did the thing so it's good to look back at that.

So I like to sort of zoom out a little bit and ask you to speculate a little bit. Right now there's a lot of hype around AI and AI assisted coding and sort of at a surface level it seems to me that being good at decomposition might make you a better AI assisted developer. Any thoughts on that? Yeah as in if you're if you're good at breaking things down both stories and code AI will be able to help you do your job better. Right you get better outcomes.

Yeah I agree with that because well let me think about this I can see it going two ways because I know AI likes to have as much context as possible. So if I'm breaking something down as small as possible and feeding it into the AI it may not have all the context that it needs. So that's just I'll leave that there I'm not sure I'm not sure what to think about that but I also know when you're working with AI and trying to solve a particular problem. I mean it's good to focus on that particular problem and not have all this unnecessary data in there. Right so scoping things down maybe can help the AI have a smaller problem to solve potentially it's harder because it has less context.

Sometimes you can break things down but not like exclude that from the context. So maybe you give it instead of saying here's a problem I want you to solve it you can say here's a problem and here's five steps I want you to take to solve it. I think even sort of a micro version of that that people sometimes do with like a GitHub co pilot is writing a comment above a method for sort of like here's sort of five steps of what the algorithm needs to do in like pseudocode or even just straight up prose. Then co pilot will fill it out mostly correct based off of that. Right yeah the thing I do think being able to break down your work will help you be a better AI assistant developer.

The one thing I'm a dork so I like solving problems and that's not to say I don't leverage AI but I find that if I can do the work myself it's not necessarily going to be better than what AI can do but I've retained the thing I'm trying to do. And that's really important to me a concrete example of where I'm doing the opposite is I am a really bad speller and I just I'm like hey spell check do this for me and I'm so reliant on spell check that I can't spell to save life because I have no retention there because spell check doesn't for me but the opposite is what I'm trying to do with programming which is like I want to actually know what it is that I'm doing here.

So I try to do that as much as I can and obviously if I'm like if it's a complete roadblock or concept I have no idea about sure it has a great tool and I use it frequently for stuff like that but if I'm basically the topic of this is like breaking things down decoupling can be helpful if you're able to understand how to break the work down. Hopefully it's not too overwhelming for you as a developer because you've isolated the thing you need to work on and you cannot worry about anything else and especially give it the corresponding test work to. So if you're working down can be all sorts of different levels right it can even be at a like full on system level here we're going to want something has like these subsystems we're going to like interact with them in such a way.

So if you're designing some kind of like authentication system oftentimes you need to sort of think in terms of larger pieces, you're doing an OAuth integration you've got to think about a provider versus a consumer and thinking in those terms becomes helpful but then yeah like we can zoom all the way in where you're like alright here are the different steps of my algorithm here are the different sort of sub methods that I'm going to want. My sort of hypothesis is that decomposition is a core developer skill today when you're doing everything manually and they will only become more valuable in a world where we have a larger presence for AI assisted tooling. Yeah I can see that. I guess you know that is speculation so check in again on the bike shed in a year or two and see if this is right or wrong.

I think you got it. You got or you can ask it right now what do you think you always ask it is opinion too. That's right what are going to be the core developer skills in an AI system world because it's probably not going to be like deep deep. Deep understanding of the new show syntax. Right now I don't think it'll be that I think it's going to be something you know you're still going to want to understand the system that they kind of go back to the whole spelling thing right like if you don't have like the retention or understanding of the system you're working with.

That's probably not going to be good for you so as a human you're always going to want to know that otherwise that will be a challenge for you and the team and the project working on if like no one or if even if collectively all the humans on the project don't quite understand everything works. That would be a concern so the ability to break things down is always going to be helpful. Yeah and having something help with sort of the minutia can be time saving you're an author writing a book writing a book spell check is useful even if maybe it does mean that you rely on it more than you like your job as an author is not so much focusing on remembering the correct spelling for every word you're trying to communicate ideas tell stories structure arguments that's the level that you're really putting most of your effort in and so a little bit of help on the spelling even if it is a crunch sometime I think is a win in the end.

Yeah now the AI for the minutia big plus one for that I love it for that type of stuff because then you can just focus on the stuff that matters. Well I feel like at some point I have to have you come back on for a real dive into AI this was an episode more on decomposition in general but yeah sounds like there's some different thoughts percolating there on the use of AI is that developing tool. Yeah absolutely I love that. Alright well Steve thank you so much for coming on the show. Yeah thank you for having me this is a lot of fun.

And on that note let's wrap up.

Frequently asked questions

How long is this episode of The Bike Shed?

This episode is 42 minutes long.

When was this The Bike Shed episode published?

This episode was published on May 6, 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.