What is Software Design?

In 1992, Jack W. Reeves published What Is Software Design?, an essay that shaped the way many of us think about software development.

His argument was simple but profound: the source code is the actual design of a software system. Unlike traditional engineering disciplines, where design and construction are separate phases, in software development, coding is the design process itself. The act of writing code captures all the design decisions, and once complete, the software is effectively "constructed" the moment it compiles.

This way of thinking influenced the clean code movement and, more broadly, the idea of software craftsmanship—an ethos that has guided much of my career. The value was in the craft of writing code because that was where the design truly lived. Writing good, maintainable, well-structured code was synonymous with designing good software.

But is this about to change?

The traditional argument that “the code is the design” may no longer hold in quite the same way. Instead, the real challenge—and the real value—will shift to precisely defining the problems that need to be solved

Large Language Models (LLMs) and AI-powered coding assistants are making the act of writing code faster, more automated, and in some cases, almost trivial. Tools like GitHub Copilot, Cursor, ChatGPT, and bespoke AI models trained on specific codebases can now generate functions, suggest implementations, and even assemble entire applications based on high-level instructions.

This doesn’t mean software engineering as we know it is obsolete—far from it. But it does mean that the balance of effort is shifting. If AI-assisted coding continues to evolve at its current pace, we may soon reach a point where writing the code takes almost no time at all. The traditional argument that “the code is the design” may no longer hold in quite the same way. Instead, the real challenge—and the real value—will shift to precisely defining the problems that need to be solved.

If this shift feels radical, it’s worth stepping back and recognising that software development has always been a story of increasing abstraction.

In the earliest days of computing, programming meant physically wiring connections on a board, setting up logic gates to perform computations. Then came machine code—writing raw binary instructions that mapped directly to CPU operations. As this became too laborious, we moved to assembly language, which introduced human-readable mnemonics but still required a deep understanding of the hardware.

The next leap was high-level languages like C and C++, which abstracted away the specifics of the CPU and allowed developers to think in terms of structured logic rather than register manipulations. Then came managed languages like Java and C#, which introduced memory management and runtime environments that handled much of the complexity for developers. Each step abstracted away more of what was happening "on the chip" and allowed engineers to work at higher levels of reasoning.

At every stage, there was resistance. People worried about losing control, about inefficiencies, about the implications of not knowing exactly what was happening under the hood. And yet, each transition ultimately led to greater productivity and broader accessibility. Developers stopped thinking about hardware registers and started thinking about algorithms. They stopped worrying about manual memory management and started focusing on application design.

Now, we may be facing the next step in this journey. Instead of writing syntax and logic structures, we describe what we want in natural language, and the AI fills in the gaps. In theory, if we trusted them enough (which maybe we never will), LLMs could take our high-level concepts—our design documents, our architecture diagrams, our problem statements, skip traditional programming languages entirely, and translate intent straight into machine-executable instructions.

In this future, the design is the design. The ability to write code may no longer be the primary bottleneck in software development. Instead, the effort will be in deeply understanding the problem space, articulating clear requirements, and crafting a robust high-level architecture that AI-driven tools can then translate into working software.

The heart of software development won’t be in the act of coding itself, but in the ability to think, design, and communicate ideas in a way that AI can turn into working systems

We're not there yet. Right now, we’re living through a period of change, challenge and wonder. AI-generated code is useful, but it still requires oversight, refinement, and human intervention. The design still manifests in the code, but AI is increasingly influencing how that code is produced. In many cases, AI can speed up the coding process, but it’s not yet capable of handling the entire design-to-code workflow in a way that replaces human engineers.

That said, the trend is starting to become clear. As AI improves, software engineers will need to spend less time writing code and more time ensuring that AI-generated code is correct, efficient, and maintainable. The role of the engineer will shift toward defining and constraining the solution space, guiding AI tools toward good implementations, and critically evaluating their output.

This evolution raises important questions about quality and maintainability. Just because AI can generate code doesn’t mean that code is automatically good. The craftsmanship that defined the clean code movement doesn’t disappear—it simply moves up a level. Instead of focusing on syntax and structure, engineers will need to focus on architecture, intent, and ensuring that AI-generated solutions align with business goals, security best practices, and long-term maintainability.

So, while we aren’t fully in this new paradigm yet, I believe we are moving toward it. In the near future, the skill set of a great software engineer may be less about typing code and more about thinking clearly, defining problems precisely, and designing solutions at a higher level of abstraction.

When that happens, the heart of software development won’t be in the act of coding itself, but in the ability to think, design, and communicate ideas in a way that AI can turn into working systems.

We’ve spent the last few decades refining how we write code. The next few years might be about refining how we design—because soon, that might be where all the real value is.

About the Author

??? This article was written by me! I'm CTO and founder of Dootrix, a pioneering software technology consultancy specialising in mobile applications, cloud-native solutions and digital innovation. With deep expertise in Microsoft Azure and award-winning mobile app development, Dootrix helps clients pioneer new solutions in a rapidly evolving tech landscape. To learn more, visit Dootrix.com or for regular bite-sized updates on all things tech, follow this link to subscribe to my newsletter: The Next Thing Now ??.