Software development has always resisted the idea that it can be turned into an assembly line. Even as our tools become smarter, faster, and more capable, the essential act remains the same: we learn by doing.

An Assembly Line is a poor metaphor for software development

In most mature engineering disciplines, the process is clear: a few experts design the system, and less specialized workers execute the plan. This separation between design and implementation depends on stable, predictable laws of physics and repeatable patterns of construction. Software doesn’t work like that. There are repetitive parts that can be automated, yes, but the very assumption that design can be completed before implementation doesn’t work. In software, design emerges through implementation. We often need to write code before we can even understand the right design. The feedback from code is our primary guide. Much of this cannot be done in isolation. Software creation involves constant interaction—between developers, product owners, users, and other stakeholders—each bringing their own insights. Our processes must reflect this dynamic. The people writing code aren’t just ‘implementers’; they are central to discovering the right design.

LLMs are reintroducing the assembly line metaphor

Agile practices recognized this over two decades ago, and what we learnt from Agile should not be forgotten. Today, with the rise of large language models (LLMs), we’re once again tempted to see code generation as something done in isolation after the design structure is well thought through. But that view ignores the true nature of software development.

I learned to use LLMs judiciously as brainstorming partners

I recently developed a framework for building distributed systems—based on the patterns I describe in my book. I experimented heavily with LLMs. They helped in brainstorming, naming, and generating boilerplate. But just as often, they produced code that was subtly wrong or misaligned with the deeper intent. I had to throw away large sections and start from scratch. Eventually, I learned to use LLMs more judiciously: as brainstorming partners for ideas, not as autonomous builders. That experience helped me think through the nature of software development, most importantly that writing software is fundamentally an act of learning, and that we cannot escape the need to learn just because we have LLM agents at our disposal.

LLMs lower the threshold for experimentation

Before we can begin any meaningful work, there’s one crucial step: getting things set-up to get going. Setting up the environment—installing dependencies, choosing the right compiler or interpreter, resolving version mismatches, and wiring up runtime libraries—is sometimes the most frustrating and necessary first hurdle. There’s a reason the “Hello, World” program is legendary. It’s not just tradition; it marks the moment when imagination meets execution. That first successful output closes the loop—the tools are in place, the system responds, and we can now think through code. This setup phase is where LLMs mostly shine. They’re incredibly useful for helping you overcoming that initial friction—drafting the initial build file, finding the right flags, suggesting dependency versions, or generating small snippets to bootstrap a project. They remove friction from the starting line and lower the threshold for experimentation. But once the “hello world” code compiles and runs, the real work begins.

There is a learning loop that is fundamental to our work

As we consider the nature of any work we do, it’s clear that continuous learning is the engine that drives our work. Regardless of the tools at our disposal—from a simple text editor to the most advanced AI—the path to building deep, lasting knowledge follows a fundamental, hands-on pattern that cannot be skipped. This process can be broken down into a simple, powerful cycle:

Observe and Understand

This is the starting point. You take in new information by watching a tutorial, reading documentation, or studying a piece of existing code. You’re building a basic mental map of how something is supposed to work.

Experiment and Try

Next, you must move from passive observation to active participation. You don’t just read about a new programming technique; you write the code yourself. You change it, you try to break it, and you see what happens. This is the crucial “hands-on” phase where abstract ideas start to feel real and concrete in your mind.

Recall and Apply

This is the most important step, where true learning is proven. It’s the moment when you face a new challenge and have to actively recall what you learned before and apply it in a different context. It’s where you think, “I’ve seen a problem like this before, I can use that solution here.” This act of retrieving and using your knowledge is what transforms fragmented information into a durable skill.

AI cannot automate learning

This is why tools can’t do the learning for you. An AI can generate a perfect solution in seconds, but it cannot give you the experience you gain from the struggle of creating it yourself. The small failures and the “aha!” moments are essential features of learning, not bugs to be automated away.

✣ ✣ ✣

There Are No Shortcuts to Learning

✣ ✣ ✣

Everybody has a unique way of navigating the learning cycle

This learning cycle is unique to each person. It’s a continuous loop of trying things, seeing what works, and adjusting based on feedback. Some methods will click for you, and others won’t. True expertise is built by finding what works for you through this constant adaptation, making your skills genuinely your own.

Agile methodologies understand the importance of learning

This fundamental nature of learning and its importance in the work we do is precisely why the most effective software development methodologies have evolved the way they have. We talk about Iterations, pair programming, standup meetings, retrospectives, TDD, continuous integration, continuous delivery, and ‘DevOps’ not just because we are from the Agile camp. It’s because these techniques acknowledge this fundamental nature of learning and its importance in the work we do.

The need to learn is why high-level code reuse has been elusive

Conversely, this role of continuous learning in our professional work, explains one of the most persistent challenges in software development: the limited success of high-level code reuse. The fundamental need for contextual learning is precisely why the long-sought-after goal of high-level code “reuse” has remained elusive. Its success is largely limited to technical libraries and frameworks (like data structures or web clients) that solve well-defined, universal problems. Beyond this level, reuse falters because most software challenges are deeply embedded in a unique business context that must be learned and internalized.

Low code platforms provide speed, but without learning, that speed doesn’t last

This brings us to the Illusion of Speed offered by “starter kits” and “low-code platforms.” They provide a powerful initial velocity for standard use cases, but this speed comes at a cost. The readymade components we use are essentially compressed bundles of context—countless design decisions, trade-offs, and lessons are hidden within them. By using them, we get the functionality without the learning, leaving us with zero internalized knowledge of the complex machinery we’ve just adopted. This can quickly lead to sharp increase in the time spent to get work done and sharp decrease in productivity.

What seems like a small change becomes a time-consuming black-hole

I find this very similar to the performance graphs of software systems at saturation, where we see the ‘knee’, beyond which latency increases exponentially and throughput drops sharply. The moment a requirement deviates even slightly from what the readymade solution provides, the initial speedup evaporates. The developer, lacking the deep context of how the component works, is now faced with a black box. What seems like a small change can become a dead end or a time-consuming black hole, quickly consuming all the time that was supposedly saved in the first few days.

LLMs amplify this ephemeral speed while undermining the development of expertise

Large Language Models amplify this dynamic manyfold. We are now swamped with claims of radical productivity gains—double-digit increases in speed and decreases in cost. However, without acknowledging the underlying nature of our work, these metrics are a trap. True expertise is built by learning and applying knowledge to build deep context. Any tool that offers a readymade solution without this journey presents a hidden danger. By offering seemingly perfect code at lightning speed, LLMs represent the ultimate version of the Maintenance Cliff: a tempting shortcut that bypasses the essential learning required to build robust, maintainable systems for the long term.

LLMs Provide a Natural-Language Interface to All the Tools

So why so much excitement about LLMs? One of the most remarkable strengths of Large Language Models is their ability to bridge the many languages of software development. Every part of our work needs its own dialect: build files have Gradle or Maven syntax, Linux performance tools like vmstat or iostat have their own structured outputs, SVG graphics follow XML-based markup, and then there are so may general purpose languages like Python, Java, JavaScript, etc. Add to this the myriad of tools and frameworks with their own APIs, DSLs, and configuration files. LLMs can act as translators between human intent and these specialized languages. They let us describe what we want in plain English—“create an SVG of two curves,” “write a Gradle build file for multiple modules,” “explain cpu usage from this vmstat output” —and instantly produce code in appropriate syntax inseconds. This is a tremendous capability. It lowers the entry barrier, removes friction, and helps us get started faster than ever. But this fluency in translation is not the same as learning. The ability to phrase our intent in natural language and receive working code does not replace the deeper understanding that comes from learning each language’s design, constraints, and trade-offs. These specialized notations embody decades of engineering wisdom. Learning them is what enables us to reason about change—to modify, extend, and evolve systems confidently. LLMs make the exploration smoother, but the maturity comes from deeper understanding.

The fluency in translating intents into code with LLMs is not the same as learning

Large Language Models give us great leverage—but they only work if we focus on learning and understanding. They make it easier to explore ideas, to set things up, to translate intent into code across many specialized languages. But the real capability—our ability to respond to change—comes not from how fast we can produce code, but from how deeply we understand the system we are shaping. Tools keep getting smarter. The nature of learning loop stays the same. We need to acknowledge the nature of learning, if we are to continue to build software that lasts— forgetting that, we will always find ourselves at the maintenance cliff.

---