Go back

// article

Kill Your Darlings, Hire Juniors

AI is forcing a paradigm shift in software engineering, moving beyond outdated mental models and we are mostly ignoring it.

Play
Transcript

[00:00] These are books, and for some of you who might not know, a book is like a podcast in printed form, and some of these books are about computing history, and one of the things that I noticed that’s common to those stories is there’s always somebody who ends up missing out because they can’t see beyond what they already know. So take Marvin Minsky, for example, who is an important character in this book, Genius Makers. He was one of the initial pioneers in artificial intelligence, but he was deeply skeptical of neural networks, and mostly because he couldn’t imagine that a machine could produce a new idea that it wasn’t explicitly taught first. And he pretty much single-handedly caused what we call the AI winter. And it’s just a great example of how even brilliant people can struggle to imagine a future that doesn’t fit their current mental model.

[01:06] So this is Refactoring. It’s a book by Martin Fowler. It is a beloved software development text, but it’s mostly like a recipe book. Like, I can pull it off the shelf, look up the technique, apply it, and put it back, and you’re done. But these two, the Phoenix Project and the Pragmatic Programmer, which is one of my favorites, these are about the principles of software development, and they teach it through parables and metaphors for how to think about software development, how to approach problems, how to make better decisions, and how to be a better engineer, because we have a tendency to understand new technology by comparing it to the world we already know.

[01:52] Your car’s engine power is probably measured in horsepower, which is a clear throwback to the dominant mode of transportation before automobiles, which was horses. And today, we still pretend that computers are little desks. You know, they have documents and file cabinets and address books and a little trash can and a clipboard, because it’s a solid metaphor that helps people. Take the universal save icon. It’s a three and a half inch floppy disk. And for an entire generation of computer users, that totally made sense. They knew it was an image of a floppy disk, and they knew what it meant to save something to a floppy disk. But there are adults today who have never seen a floppy disk in person, and they recognize that icon not because it represents something that they’ve physically experienced, they’ve just learned what it means, the intent and meaning behind it. And so the metaphor has outlived the thing that it’s supposed to represent.

[02:59] And these metaphors work. They make technology more approachable by borrowing from the world people already understood. But they also shaped what people came to expect from computers. We built interfaces around these metaphors and developed habits around those interfaces and eventually started treating those habits as though they were inherent. Properties of computing itself. But they’re not fundamental properties of computing. They’re design decisions inherited from a time when we needed to make computers more understandable to a person who had never used one. So in short, too late, a metaphor like desktop, a great metaphor, shapes a mental model. And that mental model shapes habits. And when a mental model is correct, the habits are correct. And likewise, when a mental model is wrong, the habits are wrong. When we rely on training wheels, we may forget eventually that the training wheels are removable. And you may find yourself defending design decisions made in the 1970s or the 1980s as though they were laws of physics.

[04:17] A lot of our best and good software engineering practices are derived from the cost of developing, maintaining, and coordinating software written by human beings. But AI is fundamentally changing the economics of software development, which should mean that some of our best practices should stop making sense. However, whenever I look at a so-called vibe-coded app, I see the exact same best practices being implemented. And to me, that’s a signal that we’re not quite ready to let go of those old mental models, me included. So take a book like The Pragmatic Programmer. The entire philosophy, and honestly, the whole tradition of modern software development, is based on the software developer as craftsman. You know, hand polishing every single function, obsessing over clean code, and adhering to strict policies like D-R-Y. Don’t repeat yourself. And that mindset made total sense when every single character on the screen was typed by a human hand, and every future bug meant that a human had to parse that exact code with their human eyes. But if AI can refactor or discard, you know, 500 lines of boilerplate in four seconds, it changes the cost of duplication. It changes the cost of abstraction. So suddenly spending three hours, you know, hand polishing your pristine hyper-module class hierarchy isn’t craft. It’s nostalgia. We aren’t woodworkers anymore. We’re more akin to urban planners. An urban planner doesn’t care about the precise grain of wood on a park bench. They care about traffic flow and utility capacity. And what they do is they set boundaries, they enforce constraints, and they direct growth. When your tool writes code for you, your value as an engineer is no longer your ability to write clean syntax. It’s your ability to express clear intent, to evaluate trade-offs, and to guide growth. The term for this is currently design engineering, and if you are still treating software development like you’re hand carving a piece of wood, you are focused on a bench while the city around you burns.

[07:01] Which brings us back to those metaphors that we can’t seem to let go of, beginning with how we organize our work. Well, for decades, we have kind of pretended that our software lives in physical file cabinets. We create directories and subdirectories and nested paths, all in support of a mental model based on spatial organization. The idea that in order to find something or to understand how a system works, you need to know where it lives in some sort of grid. But large language models and vector databases don’t give a shit that your helper function is buried three levels deep in a folder called utils. They evaluate code based on semantic context. What the code actually means, what it does, and how it relates to the problem at hand, regardless of where it’s physically located on a disk. And despite me seeing a lot of engineers say, I don’t read the code anymore, it sure seems like they spend a lot of energy teaching AI to organize that code based on a crutch we invented in 1985 to solve our very human short-term memory problem. We simply have not transitioned from the spatial organization mental model to the new semantic one. We still treat our digital world like a bunch of paper documents in a filing cabinet.

[08:31] All right, here is where I am going to lose a lot of you. So I’ll just say up front, sorry, not sorry. If you pay attention, if you listen to the discourse around AI and coding, there’s a narrative that’s taking over. And it says that AI tools are only useful if you’re already a senior software developer. The argument goes that you need an extensive background in software development in order to catch the AI’s mistakes. And you need to know every classic software development pattern in order to keep the system on the rails. And right now, these are absolutely the loudest voices in the room. Senior engineers looking at these tools and saying, look how much faster I can execute the things I already know. And on the surface, it kind of sort of seems logical, but it’s a trap. When a seasoned developer uses AI, they tend to use it as a hyper-efficient autocomplete for their own mental models. They write the exact same design patterns and architectures they’ve been writing since 2008, only faster. The people who are going to move us into the next software development era are not walking around with 20 years of best practices stuck in their heads. They are the ones who don’t know what a floppy disk is, and they’re not emotionally attached to DRY or traditional refactoring techniques. They don’t have to spend a lot of energy unlearning 40 years of software development dogma, and they’re not trying to make AI fit an old workflow. They are completely free to invent brand new ways to work with code from scratch.

[10:27] And that brings us to the most recent trap that we’re all about to fall into, the software factory. So for about 20 years or so, give or take, the software industry has been sort of obsessed with converting the software development process into an assembly line process. And we have succeeded in half of that. CICD works. It’s very much like an assembly line or a factory. We don’t really worry that much once it’s set up. The testing, building, and deployment of an application works great. But we are currently looking at a new dangerous leap into making the entire software development lifecycle an assembly line process. And that assembly line would be populated by AI agents who are trained on old mental models. You can imagine, you know, some sort of input where a product manager drops a specification and an AI assembly line just starts spitting out code and on the other side outrolls a perfectly formed product or application. And that’s a very attractive mental model if you believe that the modern developer’s edge is speed of implementation. It’s also completely wrong. The modern developer’s edge isn’t speed. It’s taste and verification and edge case evaluation.

[12:07] So real quick, while I was doing some research to support this video, I sought out, like, is there anyone else out there who feels the way I feel about this? And I came across this article. The agentic software factory is a wrong metaphor. It’s from about a month ago, and it’s written by Rob West. I’ll have a link in the description for it. I am going to paraphrase a little bit of this because Rob did a much better job writing this down than I’m about to babble my way through. First, a factory assumes that design is solved, but figuring out what to build and how it should behave is the work. A ticket is not a blueprint. Second, the process of developing software changes our understanding of the specification while we’re building it. It’s not spec in and software out. Design engineering evolves a specification as we learn more about the problem. Third, an assembly line is meant to eliminate variations. Design engineering benefits from it. This is how we compare, test, and find better approaches. And lastly, you have to feed a factory. And that creates pressure to formalize requirements before we understand the problem. And the ambiguity doesn’t just disappear. The agents will fill the gap with best guesses and very confidently produce the wrong thing.

[13:30] The problem with the software factory is not that the technology is bad. It’s that we’re applying a 19th century industrial mental model to a 21st century cognitive shift. And just like Marvin Minsky couldn’t see past his assumptions about how machines would learn, we risk missing the real power of these tools because we’re too busy making them act like faster assembly line workers. We’re going to use groundbreaking technology to just do the wrong things faster. The classics, they got us here. They gave us the mental models and the metaphors that we needed to survive the first era of software development. But as these new tools rewrite the baseline of what it means to build software, hanging on to those old metaphors is not going to make us better engineers. It’s going to leave us standing on an assembly line producing artifacts for a world that’s already moved on. I’m Joe Metalone. I make short, practical videos that respect your intelligence and your time. If that’s your style, you’ll like this channel.

A lot of what we consider “good software engineering” is a response to the cost of producing, maintaining, and coordinating software written by humans. AI changes those costs. And if the costs change, some of our best practices might stop making sense.

That doesn’t mean everything we know becomes obsolete. It means we should ask which practices are fundamental principles and which are workarounds for the limitations of human-driven development.


What if software becomes disposable?

The conventional wisdom: Software is expensive to build. Therefore, we must design for longevity, maintainability, and reuse.

Maybe the future of software engineering isn’t writing better code. Maybe it’s getting better at knowing when to throw code away.


What if personal software is more important than enterprise software?

The conventional wisdom: Real software is built for users. Personal scripts, hobby projects, and one-off tools are lesser forms of software engineering.

We might stop asking whether someone is qualified to build software and start asking whether they can describe a problem worth solving.


What if code is no longer the primary thing engineers maintain?

The conventional wisdom: Good engineers understand their codebase. Code review, architecture, testing, and refactoring help humans reason about increasingly complex systems.

The future engineer might spend less time understanding how a system works internally and more time defining what it is allowed to do.


What if abstractions become less valuable?

The conventional wisdom: Don’t repeat yourself. Build reusable components. Create abstractions. Invest in design systems. Generalize solutions to recurring problems.

AI might make code reuse less important while making the reuse of ideas, constraints, and behavioral contracts more important.


What if the best developer is no longer the best programmer?

The conventional wisdom: Strong programming skills are the foundation of software engineering expertise.

The scarce skill may shift from producing solutions to exercising judgment about which solutions deserve to exist.


What if the next great software is never released?

The conventional wisdom: Software is a product. It has a release, a version number, a roadmap, and a user base.

We may be moving from a world where people acquire software to a world where people acquire the ability to create software.


What if rebuilding is safer than upgrading?

The conventional wisdom: Mature software must be upgraded carefully. Dependencies, APIs, and internal architecture need to remain compatible with existing systems.

Legacy software might become less of a permanent burden and more of a temporary specification for its replacement.


What if software is no longer designed for humans to operate?

The conventional wisdom: Software needs a good user interface. Navigation, forms, menus, dashboards, and documentation help people use it.

The future of frontend engineering might not be building interfaces for people to click. It might be designing the systems that allow agents to act on people’s behalf, with interfaces reserved for oversight and trust.


Share this post on:

Next
JEV: The Unusual AI Model I Think Could Be Really Useful in Real Applications