Hello and welcome to another episode of the Bike Shed, a podcast from your friends at ThoughtBot about developing great software. I'm Joel Kinville. And I'm Adji Slater, and together we're here to share a bit of what we've learned along the way. So, Adji, what's new in your world? What's new in my world has been the same new thing in my world for the last couple of weeks, actually. We have a component in my current project that just seems to
be collecting all of the bugs. It's a React frontend, or Rails backend, not that the Rails really comes into this, but it's one of those steps in a large form. It's not really a wizard, but you can kind of think of it that way in some instances. And this one step has collected a lot of responsibility over the lifetime and existence of this component. And it contains a couple other little components that sort of conditionally rendered, depending on other steps in the form. And there is just a lot of state
management going on that. Kind of as new features have rolled out have sort of grafted on new ways to think about it and new ways to handle it as different teams or different people have touched this component over its long life. And as it becomes more integral to more and more different features and workflows, it just kind of takes on a lot of more queries, a lot more touching other parts of the state that exists outside of the form and inside of the form. And it's really kind of at that breaking point that it was the thing that just kept coming up in conversation amongst the devs. And when I joined the team, it had already gotten kind of far past the point where it took up a lot more headspace than it really felt like it deserved as far as like what was the valuable thing to be working on in the application and things like that. So I have just found myself first out of
just coincidence being the one that picked up the particular bug tickets for this component. And then I started seeking it out as I kind of got more and more of an understanding of what was going on in there. And wanting to iteratively kind of spread apart and simplify the parts of this form and kind of get its various pieces all working in the same way and kind of thinking in the same way. Because you know, there's parts of a code base that have just had a lot of different people touch that they've gotten big enough that it's not easy to see at first glance what everything is doing. And so the patterns that are more familiar to one person gets added in where it may have been a little bit more beneficial to kind of stay with what existed inside the component. One of these path-to-back code is paved
with good intentions kind of components. And it is now designed by accretion kind of thing. Yeah, yeah, exactly. It's not quite designed by committee because it wasn't this big upfront design or anything. It's yeah, accretion is a really great way to describe that. It's just sort of this sediment of new code
is layered on top of it. And you can look at the layers. The git blame is just this stratification of these different colors and names and PRs and everything like that. And so as it's come up, I tried and took maybe a day or two and tried to just big bang, go in, do the refactor, do the act shave that's going to save everybody. But eventually I had to pull myself back to like, I am just an rabbit hole and I'm not helping move things forward. This could take so much longer
than I thought and had to kind of drop what I was doing, put it through a couple of small PRs that didn't get necessarily close to what I was trying to do in the first place, just like save some of the work and then revisit it a little sliver at a time and kind of shave up. Okay, this one, I can refactor this function out or I can make this into a hook or I can bring this into a used query the same way that the other queries are as opposed to some other methodology that was going on underneath it and just kind of erode away those different layers of sediment. And so the thing has been new for me. It feels as though it's been the exact same thing for a month, a month and a half, but it's just been revisiting this site and kind of not even like an archaeological dig, right? Because I did so much of that studying of those layers and examining where everything's going. I have pages, pages in my
notebook of notes of where the state is going through in this component, but just kind of keep coming back to this. And I sort of look forward to these tickets because it's like, oh good, I can get a little bit further on my big project, but still like solving a bug or solving a problem for someone at the same time. It sounds like this is kind of a background thing for you. You've not been doing like a month and a half of just refactoring on this. This is like, you're doing other features or bug things. And as relevant tickets touch this, you use it as an excuse to do all right.
I'll do one another little refactor sliver here. Yeah, it feels like that for me. And certainly that's what the story arc in my head has been. But I think from the outside, you would just see it as tickets moving across the board, like that I picked up a lot of bugs and that kind of thing. But yeah, it is exactly that. It's my white whale or whatever right now that I want to get to a place
where the rest of the team doesn't intentionally pass those tickets on to avoid them or that the rest of the team doesn't feel a sense of dread if they have to go into that component again. And so yeah, that's been my kind of background process. But it's also been my foreground process a lot of the time, too, because each one of those little bug fixes, instead of just throwing a bandaid on the top, is a little opportunity to dig into it a little bit and get some of that big bang refactor done, just spread out. I feel like I've been in a similar type of situation and tied specifically to multi-step forms on a couple of different occasions, both in front and code and back and code, where it's like, ah, the multi-step form kind of coordinator pieces just got to be this horrible thing of logic. And we're all afraid to touch it. Hey, you do you want to add other
features that or hey, you, this has gotten so bad somebody needs to refactor it, not yet. Can you do it? Yeah. To the point that I wrote an article about, hey, I've done this a few times. Here's how I like to approach this kind of problem. I think there are problems like that or things that,
especially as consultants, we see that may hit some kind of recognition or something's like, oh, I know the feeling of being there or I can see something in how this team operates around this one part of the code base. It's like, I am not afraid to dive into that again and kind of take a crack at it and hopefully you can alleviate a big recurring piece of stress for the team that I'm with right now and that kind of thing. So I think multi-step forms, that comes up quite a bit. State management problems and React, which is really what this one is. And that one for me, I like those kind of challenges in teasing those things apart. So yeah, for sure. And that can be some of the value of bringing in
an outside consultant because people who work on a lot of different projects often encounter the same sort of gnarly problems multiple times. So you bring in someone like yourself on this project, it's not a sort of inscrutable or really frustrating problem. It's a pattern I've seen before. I have a personal approach I like to use to fix these. And then also part of the consulting philosophy that we are very careful about is the balancing of that with broader picture priorities. How do we
keep making so that you're not there for a month just refactoring but actually shipping value while also untangling this thing for the team in a way that's sustainable and that leads to real change. Yeah. And the other aspect of being an outside eye and coming in without understanding the baggage or the different stories and features and rollbacks and things changes that led to the code as it is, you can kind of see it for exactly what it is without all the different emotional or the storylines of the thing. You're not connected to it so closely that you can actually just sort of trace things apart and start to peel those layers away. And I think there are times when that outside eye, I mean, I think there are a lot of times when having that kind of outside eye is incredibly valuable. Sometimes you do need to end up and find out those stories. But yeah, that's another reason
why I like the position that we can occupy as consultants and being able to drop in and kind of have a little bit of a superpower that way. What's new in your world? I did a frivolous side project. Those are always fun. It started. I was on vacation and I'm a history nerd. I saw a coat of arms. I
didn't recognize. I was like, I want to figure out what this is. I took a photo. I'm like, I'm going to look it up at some point and then realize, wait a minute, I have tools on my phone that should be able to give me the answer right now. And so I dropped it into chat. GPT is like, tell me what
this thing is. And it was hilariously bad. Like, it's like, you're not actually looking at a coat of arms. You were looking at a statue of a dog in Spain. And it's like, pretty sure that's not the case.
But what's really cool is that the app does allow you to expand the reasoning and you can sort of see how it got to that place. And it's just anchoring bias all the way down, whereas like it saw there was an animal on there. It's technically was a lamb on the coat of arms. The coat of arms is rendered in bronze as like a relief. And so let's go like, oh, bronze animal that kind of looks like a dog, bronze dog. I found a red post talking about a bronze dog in Spain. And then just kind of like
daisy chains off of that. And gets to like pretty ridiculous conclusions. And so of course, at that point, then I'm like, if it's this bad, I'm curious what other models do. And so I started just trying all the different models I had access to on my phone, then opening up the reasoning traces to see what they actually did. Some of them succeeded, some of them failed pretty laughably. But when I was looking at the ones, particularly the ones that were got like
partially right and then got off on a wrong trail, I was trying to compare that to how maybe I would approach doing a search like that. Because it is effectively a search and you're going through a search space, some of which is physical. You know, you're probably somewhere European or European influenced. And then you like, you work with some of the symbols to try to reduce your like land area based off historical things that you know, geographic things and you're constantly trying to prune the search space while also keeping the ability to backtrack. And I was like, I would love to see this visualized on a map. I also love maps. So I get home and I start writing scripts and
things to generate maps. And I take these effectively reasoning traces, but they're kind of like a search through a search space and trying to plot them on a map and build a whole lot of tooling around map generation to get these things. And like pretty soon, I'm like, all right, I've got like a map of Western Europe and it's, you know, we'll have like a zone that's highlighted where it tried to search in the different zone for a different place it tried to search. You can see if there's any overlap or not. You can see particular points it tried and backtrack from.
I had way too much fun digging into that, digging into some of these things that searched into that may or may not be plausible. I don't know why did you look into this particular town? Oh, it turns out that this town's patron saint is Saint John the Baptist, who in iconography is associated with the lamb as his image. And so because there was a lamb on my coat of arms, you searched for towns with Saint John the Baptist as their patron saint. Kind of a reasonable thing to do, but like, it can lead you to some really bad outcomes too. But you know, I learned some things about iconography along
the way. So I just had a lot of fun nerding out and digging into that. I ended up taking all of this, all the maps and a little bit of an explanation of the reasoning traces and all that and throw them together into a blog post. So I'll link that in the show notes. But that's been my sort of frivolous side project going deep into heraldry. That's really incredible. I love that. Oh, here's a really
fun heraldry note that I discovered as part of this is really fun. A way that a lot of the models that were doing kind of well then got tripped up is that there were like very thin vertical bars in the background of the coat of arms. And a lot of the models saw that and were like, oh, vertical bars, there's a really famous set of vertical bars. They're sort of the base of the coat of arms of Eragon, which is sort of a region of northern Spain, kind of Barcelona-ish area. And those get then reproduced across a ton of different coat of arms and have associations with that region.
And so they see vertical bars and like, all right, that's probably it. Turns out it's not that. It's not even a like motif. It is something entirely different where when you're working in a monochrome medium like bronze and you're trying to indicate color, there were conventions for like texturing the background in a way that would indicate color. Oh, wow. So vertical bars mean red, horizontal bars
mean blue. It's sort of really thin. It's called hatching. And that was I think it evolved from some kind of printer's guild or something like that. Sure. Yeah, or like printmaking. Yeah. Yeah.
Which, that's a really cool thing to learn about. But also we'll absolutely throw off a model who's thinking of like actual geometric patterns being part of the design rather than a like artifact of the medium. Right. Wow. Were you able to like teach it that or compensate for that? Or was
that just kind of an interesting side quest or something? So most models failed on that. Opus from anthropic was able to turn for 10 minutes trying to identify his image. So he was trying all these random things and it's like he reads reasoning trace me is about to give up. And then it like somehow stumbles across this idea is like, wait a minute. I think the hatching means red. And the
moment it gets that all the other blocks fall into place and it converges on a solution on the correct solution. Wow. It took 10 minutes to figure that out. That's wild. I do want to go back to some of the ideas from the thing that you shared about that's new in your world. Because I think the sort of incremental
ism that you're talking about lines up a little bit with kind of a big happening in the dev world, perhaps overshadowed by some of the AI stuff that people are talking about. But I get how released stacked PRs. That's a really big deal in terms of workflow. Yeah, you know, I'm aware of it, but I haven't had an aid or an instance to use that at all. Have you gotten much personal experience with it? I know
a few thought about it. Yeah, I've done like one tiny snack PR that was like two PRs long, haven't really gotten a chance to use it in anger because my project is actually based off of the Microsoft stack on Azure, including their version control system. And so I'm not doing a whole lot of like sustained work on GitHub the these past couple months. So what is the innovation? What is the big idea behind this? The idea of creating a chain of commits is not new. This exists for a while.
In fact, GitHub allows you to do branches off of branches, but the affordances on that have always been really clunky. Sure. Like it was hard to like say I want to merge the entire stack. I want to merge half of the stack. And then if you ever like merge parts of it, you had to go back and like rebase all the things off of each other so that things were good. If there was a merge commit,
or if there were any changes in one of the lower ones that might propagate up, then it just there was a lot of like logistical stuff around it that made it kind of really annoying. And so what people might do is instead create like a long running branch and just do one giant mega merge at the end, they might try to just do a giant squash, and you lose all your commits. There are a few different ways that people tended to do that just because the logistics part of it was a little bit clunky and annoying. Sure. Sure. Yeah. And there was third party software like Graphite, which gave
something kind of like the stack PRs on GitHub. That's a third party tool. That's true. Yeah, I can remember plenty of times where I've had either a long running branch or branching off of other branches that are running into exactly what you're talking about, that kind of merge conflict or the rebase that just cycles through and you have to spend half an hour going through all the different merge conflicts and different things like that. So this is an attempt to give a little bit of UI sugar to that workflow is kind of what you're saying. Maybe not UI, but like a... Yeah. So there's a
little UI, which is the UI stuff is actually quite nice because another thing in the UI, you can kind of tell by looking at a PR that it's branching off another branch, but you can easily miss that. But if you're like in the middle of a branch and you're like, where does this sit in the stack? People sometimes leave comments being like, this is a PR one of five. I think the Graphite tool would leave comments as well with the diagram. So people kind of ad-hoched it, but the UI is definitely an improvement there. But also I think the Git mechanics underneath, which was really just sort of
housekeeping. Anytime you introduce a change in a lower PR, you have to like rebase the stack above it and keep it current and all this stuff. Yeah, a lot of extra manual work and overhead. Yes, that should be really nice. I'm curious, even sort of in the game, I call it the battle days, how much you've leaned on a workflow that involves branching off of branches or sort of ad-hocing your equivalent of stack PRs. Yeah, I think generally I would try to avoid it, but there's not always
that possibility. Yeah, I think something that sort of helped was the introduction of draft PRs was super helpful because you could have one that was sort of like the focus at any given time and like make sure that that one went all the way through. But then again, when you unwrap the next one, there's inevitably a lot of management that you would have to do to that to get it ready to sit on top of the other PR unless they were going in completely without any changes and comments and reviews or updates to main underneath it, which is possible but unlikely. I think a technique that's kind of close to that is that maybe is a little bit underneath what this actually is, not as complex as to really craft the commits to a PR that could kind of tell a story of that as you're reviewing, hopefully be able to step through the PRs and kind of see the logic and the change going on. That's the same kind of like stepwise implementation or like rollout of a change, but it's certainly not going at once.
Right, that's just kind of a conceptually different steps to the one change that is going in at the same time. So I think in the way that both you and I conceive of commit history, whether you did one PR with all these little commits sort of telling a story on them or whether you did a sort of ad hoc stack PR or one of these new stack PRs, our goal for the eventual history on the main branch would be the same, right? Is that a bunch of these little independently deployable commits all end up on the main branch. I think that gets at something that is a distinction that's really important to me, but I think most developers tend to sort of conflate and that is the difference between a commit and a PR. To me, a commit is a unit of change. And a commit should be atomic. It should be
independently deployable. No commit should be broken code. I mean, occasionally I'll ship something to bug, right? But like your commit should pass the build. And if the commit is on the main branch, it should be deployable at any time, especially if you're in a continuous deploy mode, other deployments, things as well. And this is true, especially on the main branch. On a feature branch
or whatever, if you've got a bunch of work and progress commits or whatever, like that's totally happy. But when it goes into main, it's going to be, each commit has to be independently deployable. And generally I also add the stipulation that it can't be just dead code. So no, just like introduced a model. It doesn't do anything. I tend to like pieces that are wired up and actually
do things in the code. Whereas PRs for me are not a unit of change. They are a unit of review. And so PR allows you to bundle one or more of these units of change together in a way that makes sense for a reviewer to look at them. So a PR is then all about, or asking like how many of these together, does it make sense for a reviewer to have a good story without overwhelming something, makes it easy for them to review. A classic split that I will do is a refactor that sets me up for
a feature change. Like the other can't bet quote the make the change easy, then make the easy change. Great. And I like to make those typically two separate commits. One commit is a pure refactor, and one is a feature or some feature works that builds on it. Do those belong in the same PR?
I don't have a strict rule on that. I like them to be distinct commits and I want them distinct commits on the main branch. But whether I put them in one PR or not probably depends on size. And how much maybe they relate to each other or how much they one might illuminate the understanding of the other versus confuse. So sometimes I'll put the two together if they're small and they illuminate each other, they might go in one PR if the diffs would get really confusing together, especially if they're refactors mostly a move. And then the feature is an edit being able to see
those diffs separately is often really helpful. And so then I might do separate PR. Absolutely. Yeah, I think I potentially was, you know, conflating a little bit of those to that distinction that you're making right there, the unit of review versus the unit of change. And so what does something like a stacked PR afford you then that you're not getting from multiple PRs? I guess I'm wondering what is the
conceptual difference between the two? Are you hoping that the same person is going to be reviewing the multiple PRs through this stacked PR process? Like how does the change? That's the beauty. If you have a bunch of changes and previously you didn't have stacked PRs, one thing you could do is what you were saying earlier is you just put all those nice little commits into one giant PR. That can be a lot to review. And it also means it has to all go out at
once because you're merging that. And then reacting to fixes within that is going to potentially be challenging. Because then you're just going to pile on a bunch of review feedback at the end, which is not really a commit you want on the main branch. You probably want those squashed into some of the other ones. So that's annoying interleaving. Also, you can't split it among multiple reviewers.
So someone could take half a day or something and just step commit by commit and leave feedback on each commit, or maybe they split it up amongst reviewers or something like that. That gets kind of clunky. Yeah, that's asking a lot of a team or especially if that's not just one person. Yeah, as opposed to even sort of old school where you'd say branch off a branch off a branch off a branch, then you can have someone look at a PR, approve it, merge it, it's a small change. And then maybe they go at the next one, maybe somebody else does. So it allows you to distribute the review load
more. It also allows you to have like partial successes where some of your commits are merged and potentially even deployed while others are still undergoing review. That can be really good when you have sort of a uncontroversial foundation that everyone's like, yeah, we needed to make that refactor anyway. And then maybe the feature you build on top, there's controversy around how you implemented it. And then it keeps the discussion narrower on the actual controversy, but also means that the controversy is not gating that changes everybody agrees on.
So with the stack PR does it all hit main at the end? I guess I'm maybe still missing something that makes this different than just having multiple small PRs. What is the innovation here, really? So it's a little bit of your wide improvement. And I think it auto rebases the entire stack when you change things lower down the stack and when you merge. So you don't have to do the logistical
stuff. I think you can merge the entire stack. I've not tried that. But the general idea is that each PR would sort of get approved and merged independently. I'm sure there's a lot of really interesting workflows again. I've not pushed to see the edges of like what sort of wild things are
allowed with this new system. Something that I would personally be kind of excited about that might be pushing some of these things too hard is making this stack PR thing. It's not a stack. It's not a tree. It's a bag. I want, yes, I want the ability to say I've got some base refactor work. And then I've
got two independent things that build off the base refactor work. But there's no dependency on each other. So those can be sort of siblings. But maybe a fifth thing then requires those two in order to merge a build on top of both of them. Okay. I guess where is there a value to working
that far ahead or should kind of those underlying things land before you start building off again? When is it getting too far away and too into the future without having enough consensus to land the earlier things? I guess the one thing I can think of as I'm saying is that you're demonstrating the need for the earlier changes by saying this will allow us to this new thing. But coming at it with the approach of I am someone who does not have the context of having worked in each of these different nodes along the process. When is that more overwhelmed than is helpful to add all of this complexity on a change or series of changes? I think you've really put your finger on the key
issue here. That is that you don't want there to be a sort of bleed in responsibilities between them. Each of these must stand independently and must be understandable. You can be like, all right, it's part of a greater effort. I can see maybe that a later work will build on this refactor. There's a justification for it. But I shouldn't need to read the code for the other
things to understand the code on this PR. If I do need to do that, then the author has not correctly chunked their work. I think it's hard to do as a developer. Is that chunking? And it's also a thing that is the failure mode for stack VRs. But any sort of trying to do a bigger piece of work and
then splitting it up, if you've done it poorly, whoever interacts with it needs to understand the whole thing and doesn't get any of the benefits of splitting it up. Yeah. And I think that there is also just an inevitability to some of that conflict though too. Because even if there's a feature or something that has landed and it later worked, maybe six months a year down the line is using some of the work that's already done, there might be things going on in a new change that you need to understand in order to understand how that changes being used. So maybe it's different ways of conceptualizing and chunking up or talking about larger changes across the code base. And that's
that kind of the organization and sharing of knowledge there is I think one of just sort of the fundamental problems to solve working with a team across a shared complex code base. I would say that decomposition is a key developer skill. That's the thing we sort of build over a career in getting good at it. It's a thing that will be a multiplier on your ability as a developer. Decomposition all sorts of ways. It can be breaking down responsibilities into separate objects that
are nicely encapsulated. But it can also be decomposing a task or some work into pieces that can be again sort of encapsulated so that they can be read and understood without needing to fully understand the other pieces. Do you think there is I don't know if a devaluation or kind of less of a focus on that or something like that? Some of these newer tools like LOMs and agents are maybe devaluing a lot of what were necessary skills or they are putting a little more strain on being able to do that as we are making these bigger changes. These kind of other changes that I guess is there a friction or a strain being put on that skill or the lack of that skill with some of these new tools? Have you
seen that? Do you feel that? Oh boy. You have hit me in a place where I have a lot of opinions. No.
Get ready for some hot takes. Yeah. Okay. I would argue that these skills are more valuable today when interacting with an LOM than they were even in the past. Oh absolutely. I think I definitely
agree with you there. I don't think this is out at all. I also think out of the box, LOMs are really bad at this. Right. And this is partly because they're trained on a lot of existing developer material which is really bad at this as well. And the classic way that you will see this failure mode
is you're asking an LOM to build a feature and you're going to vibe code something. You know, let's ignore code quality for a moment and just think that you've asked it because you want it to be easier to review. You've asked it to split it into chunks to make it easier to review. What the LOM is going to do out of the box is it's going to do, oh I'm going to ship your model layer. Then I'm going to ship your controller layer. Then I'm going to ship your view layer which is the sort of
mistake that I think a lot of junior intermediate programmers make. And we sort of, I've definitely done that in my earlier years. 100% and learning to change differently. No, I think that's an incredibly common early career approach to take. Yes. But I think because of that, that is sort of
proliferated around the internet and a lot of the training data and it's sort of the default way that a LOM will tend to split things up. You can instruct it to do it differently. It tends to respond, I think, decently well to the keyword vertical slices which I use all the time, like pre-LOM. That was my, I didn't invent the keyword but it was a keyword I repeated a lot for this idea of going through the whole stack and shipping actual behavior rather than just code changes. Yeah, I think you may have heard me refer to that maybe not quite by name in my definition of what a commit is earlier. Yeah, I think looking for vertical slices is something that is very deeply
embedded in thought bots DNA of how we want to work and how we prefer to work and how we think work is effectively done. Yeah, because not only at a code level does this allow you to build slices that have fewer dependencies, can be shipped independently, can do all these things. But also every little bit of work that goes out is delivering value. So you're doing sort of continuous stream of value going out to customers rather than being like, I did some work but nothing shipped yet, did some more work, nothing. And just piling on the commits with no value and then a big release at the end. I think it's also one of the things that is hardest to communicate conceptually to someone
who hasn't worked like that before. And I think a very easy way to conceptualize something being done is the waterfall is a big release at the end. And something that I'm sure you have, I'm sure many consultants, many just developers in general have had to do is to walk through with someone what the value of working in that way is. And not only from a behind the scenes kind of workflow perspective, but also for the user and why that might be desirable for the end result as well. I think I definitely agree with you that these skills that we're talking about to composition are more valuable now. I think when I say that they are undervalued is maybe that they are being
made more challenging or more easily brushed aside with these new tools that kind of by default go in a different direction or work in a different way as you've been describing these kind of horizontal slices that an LLM might sort of prefer to work because of the training data. And something I keep coming back to lately, we're going to have really big ideas that we definitely don't have time to like wrap our minds around in this single conversation. But it seems that we've spent a long time as an industry and me only being the last 10 years at it, but we spent decades finding out good things about how to work and finding out ways that are effective and better being, I don't know, such a blunt instrument word for describing this, but that these tools are now speaking most about LMs have made a certain aspect of the work. So easy to produce that a lot of times those pillars of knowledge and kind of pillars of the craft are being kind of thrown out the window because we've got a whole new way to do things now. And it feels like we've learned some important things and shouldn't we
bring those important things with us. And these tools are, I find frustrating at times because they make it so easy to throw out those pillars because it can look like we're doing the same thing but faster. And I think that friction and that stress in the system comes when we're realizing that, no, we've actually thrown away something good in the pursuit of something else. I want to build on that. And this is maybe getting into hot take territory. I think that using those
kind of timeless engineering principles in the context of working with LLM is what is going to differentiate those who get good results versus those who get mediocre results. At some point, just throwing more LLM stuff at building these giant blobs of code and not thinking about not decomposing your work incrementally is when it gets you worse results than someone who's a little bit more thoughtful, someone who is maybe chunks of their work, someone who is thinking about boundaries, things like that. And this is going to be in sort of the more classic how do you do your commits and ship value and commensories or the product side of things. Turns out that's also the thing that applies to sort of core LLM problems, such as context management. A giant session that tries to do everything, runs out of context, and you get attention degradation and a bunch of negative things that happen there. If you chunk your work in this nice little, you know, directed acyclic graph of smaller
tasks that are all independent and don't require all this extra context, you can throw an LMM at them and it will complete the task within its context window without needing to compact or do any other things that lead to a sort of degradation of the results that you get. And so there are some problems that are inherent to LLM sort of novel problems like managing context. And the solution is often not some new AI level solution. It's bringing in the old wisdom and applying it to a new situation. Yeah, absolutely. It kind of goes back to that old chestnut of like, it's never actually a technology
problem. It's a whole like a people problem. You're not going to solve it with a new tool that is going to obviously completely remove the issue. You might like change it, move it around, make it easier to reason about. But I think these are things that aren't going to be necessarily solved with just adding a new layer of technology onto it. You're going to add new tools, you're going to add new
ideas, but they're not going to be the need for those pillars. And I would encourage both of us, but also our audience lean on the classic wisdom of software engineering and consider the ways that some of these ideas are helpful when thinking about working with LLM. Or if you're feeling stuck or frustrated with some stuff that LLM does, you might not need some sort of new magical AI native technique. You might just need a few classic ways of engineering things. Heard me reference DAGs, directed at A-6-C-R-Graphs multiple times on the show today.
I happen to be a huge fan, maybe more than the average developer. They have a lot of ways where they're a useful model to think about decomposing work, decomposing problems, thinking about how things connect. I think definitely still apply to the LLM world. So whatever it is that you're digging into, there are classic, timeless techniques. I think that now is the time to double down.
Yeah, absolutely. And I think we should definitely come back to this topic and think about more these ways to apply these techniques and these philosophies or anything to working with an LLM. But also, I'm really interested to come back to this conversation, not just of a single developer working with an LLM, but also how do we work as a cross-disciplinary team when there are maybe some preconceived notions being brought to how work gets done now from non-developers or how does this change the workflow now that there are new ideas about how things should be done that actually require this doubling down instead of this throwing away. Yeah, I know this point where what call it what, a year, sixish months into LLM's going mainstream-ish in the software development world?
I feel like a decade. I'm sure it's more than a year, but yeah, it's probably still less than it feels like. I think that the watershed moment a lot of people talk about is Christmas 2025 when I thought I'd release a bunch of models right about the same time everyone was going on on holidays and people were experimenting with them. And there was a bit of a sense of like, oh, this is a stepwise change. And now I'm actually able to generate code that actually kind of works whereas previous things have just been a little too janky to use as an actual workhorse. Yes, that is definitely a moment
that I can remember many different people talking about taking one of these tools away over a Christmas break or an end of the year break and coming back with a very different opinion of them. So, 100%. Was that only this last December? What a year it's been. Yeah, it's hard out there right now, fam. So take care of yourself. We'll see you on another episode of the Black Shed.
All right, let's wrap up.