~5 min read We make so much code now via agents that figuring out how to understand it all has becoming its new problem area. And yes, we do need to understand it. In order to do that, you must read it. You cannot simply stop reading it and let agents proxy your understanding. "Just stop reading the code" is an idea I first heard about a year ago. The argument goes there’s no way to keep up with the amount of code being made, so if you’re reading the code, you’re doing it wrong. When I inspect these claims, these same people never really offered much in the way of defense of their ideas. Rather they tend preempt serious criticism of their ideas in saying, "well, your code was never that good" or "all enterprise code is crap anyhow". Basically, you have no standing to criticism because it's always been slop. Let me offer you 3 reasons why you should keep reading that code as it goes by. First and most importantly, reading the code still matters because agents' outputs are only as good as their inputs. And for inputs, we have the training data upstream of the model and the incoming prompts. Researchers often described back in 2023 the original ability of models to code as an "emergent property". I think it's worth pointing out that means back then we don't know why this happened. It wasn't trained to do that. And still to a great extent we don't quite understand why models are following patterns that are not in their training set. For instance, like new programming languages model could have never seen before, like pony. Pony has seen a lot of language features added over the past year and are impossible to be in the training data. As as this talk breaks down, the models available at the time largely guesses at what the features could be. Yes, since then models have been RL-ed very heavily to be better at coding. However, that's mostly been beating out of them their tendency to do destructive behaviors and rewarding them for following what you ask them to do. Which leads to my second reason. Second, reading the code still matters because agents tend to do only what you ask. And primarily this means implementing the functionality you asked for. This behavior seems relatively stable across the past year almost 2 years of my experience from Jan-Feb of 2025 when I started using goose in with various GPT models to now where I'm using pi with a mix of Fable/Opus and Astra/Sol. Early on this blinders-approach tended to lead towards code that simply didn't function, as they went straight to implementing and ignored the broader scope. Now when everything goes right, on a good day, it'll follow existing code patterns. Usually only with a good prompt, which may or may not include a solid AGENTS.md or skills in the project. A professional software engineer doesn't tend to behave this way on average, and a place of good engineering culture would push back on poorly organized and thought through code, even when under a deadline. Especially when it would take no additional effort to recognize the patterns that were already present and work with the grain instead of against them. Code is always hard to illustrate. So let me draw some lines instead to make a point. Below are two groupings of text. Both took me about the same amount of time to make by hand. For drawing A, I took no time. I just drew out some lines. I didn't even count them. For drawing B, I just had to do a little bit of intent, which even the most average software engineer would tend to follow naturally the pattern I introduce of grouping by 4s. With agents, you have to use a sufficiently intelligent model in order to get them to realize that there's a grouping pattern and they should follow it. If you use a dumber model, you risk having some implicit pattern not followed at all and having a new pattern emerge, like say grouping by 5s with 4 lines and a 5th strike through. If you explicitly point out the existing pattern of grouping by 4s, you can hand a task of adding additional lines to relatively dumb model. But (a) that's tedious and (b) every single token going into the context window matters. Third, reading the code still matters because agents hardly ever create sustainable new patterns, and you will need those as systems grow. Those patterns will be novel to whatever the domain is for that system. You will have to decide on a pattern to solve some new problem. And it is here where if you're not watching the code go by, you will be creating tech debt in terms of the system you're building. And to be very, very clear, that may be fine. Tech debt should be a deliberate choice you make. Usually, it's specifically in the case of building something that you're not sure that people want right now or not in its exact form. So you might be tossing it anyhow. But at some point, someone will be paying someone else for whatever this system does. And upon that day, you'll have to slow down and establish the patterns. You might even need to—gasp—write a few examples of what you want—double gasp—by hand! Then you must have some understanding of how things are organized, even if it's as a coarse high-level. I have done a lot of this pattern this year of blasting out a lot of code via an agent and once the thing loosely begins to match how I want it to work. I slow down and methodically begin to organize and establish patterns. But in order to do that, I kind of needed to know where the code was and how it worked at a high-level. I encourage you all to keep doing the same. — Robert This message is 100% organic human effort, so it will have typos. No, I didn't send it through an LLM to typo check it. It was made with just my fingers and my eyes and talking aloud to speech-to-text sometimes. |