Craftsmanship vs. Abstraction

Change

We remake ourselves over our lifetime, usually as a result driven by personal change. Sometimes it comes from shifts in our own lives, and sometimes from inspiration we feel compelled to pursue. Either way, it tends to be localized to an individual journey. What is happening right now feels different. This is a shift on a national, and possibly global, scale, one that demands change regardless of our personal feelings about it.

Software Development: A Story

This is especially true for software developers, in part because the story of software development itself is a complicated one. What began largely as a theoretical pursuit morphed into applied mathematics and has, over time, splintered into many disciplines without ever consistently changing its name. The result is a field that encompasses a wide range of roles, mindsets, and motivations, all operating under the same broad label.

It is hard to ignore the fact that many of us might be better described as applied software engineers. We take discoveries, patterns, and abstractions from the past and apply them to the development of user-facing tools, applications, and entertainment. While there is often a component of logic involved, the balance frequently shifts away from pure science and toward something closer to art. In this sense, many developers did not need to fully understand every underlying technology they used, although it always helped. Instead, more energy was spent deciding how to apply those technologies effectively. That effort was equal parts logic, skill, creativity, and psychology. The best practitioners understood the consumer, understood the technology, and understood how to combine the two in new and compelling ways.

Along the way, certain developments made developers’ lives easier to the point where it became possible to ignore much of the underlying technical complexity and focus instead on the creative output. Some developers, with a predilection for logic, problem-solving, and math, preferred relying on their own skills to build what others asked for. Others preferred being closer to the customer and tended to assemble solutions from prior work. The vibrant ecosystems of widely used packages, like npm, PyPI, or crates.io, are manifestations of this shift. Communities like Stack Overflow, and Expert Exchange before it, began as places to solve shared problems, but were often used as a way to quickly copy and paste solutions directly into projects.

IDEs began to grow more intelligent about the repositories they were editing. Language servers for many common languages started providing insights into codebases that previously would have required strict discipline, consistency, and well-maintained documentation to uncover. Over time, IDEs themselves built communities of extension and plugin creators who enhanced the experience further, to the point where large-scale refactors became possible with the push of a button. This was made possible through a combination of IDE extensibility and increasingly powerful language servers.

Enter AI

With the introduction of GPT-2 in 2019, the field was quietly preparing for an enormous leap forward that would not be fully understood for several more years. GitHub Copilot began integrating AI into the VS Code IDE via an extension in 2021. Where language servers helped developers finish typing keywords, variables, and function names, Copilot started completing entire functions. Originally seen as an impressive improvement to autocomplete, it was not fully understood as the precursor to today’s agentic development workflows. Instead, it functioned as an accelerator, impressive but fallible, often suggesting incorrect implementations that could be easily ignored.

In 2023, an agent called Auto-GPT was released, wrapping GPT-4 in a loop and dynamically prompting it based on an initiating request from a human. The goal was no longer just to complete a developer’s thought, but to make it unnecessary for the human to think too much about the how, allowing them to focus more on the what. The difference was subtle but profound. This was no longer a tool that merely suggested code, but one that could decide what code to write next.

Around the same time, tools like OpenDevin emerged with a more explicit focus on coding. In 2024, Devin was released and marketed as an AI engineer. Built by Cognition, this ambitious tool arguably missed the mark in practice, but it established an important precedent. It demonstrated a harness that could operate within its own environment and take a task from request to deployable output with minimal or no human intervention.

At its core, the tension revealed by these tools is not between humans and machines, but between craftsmanship and abstraction. For decades, software development has oscillated between deep understanding and higher-level assembly. Agentic systems push that abstraction further than ever before, raising uncomfortable questions about what it means to know a system versus simply directing one.

With the introduction of models specifically designed for coding tasks, we now have cutting-edge systems like Opus and Codex that genuinely unsettle some engineers, because they actually work. It is hard to claim they are truly autonomous, but it is equally hard to ignore that such a reality no longer feels distant.

Reorient to Human

So now what? We return to what humans do best. We reflect on what makes us human and re-orient around it. For thousands of years, we have created tools to make our lives easier. While the speed of change today is uncomfortably high, this is a moment to reconsider what makes humans special and to view this latest tool not as a replacement, but as an opportunity. It is an opportunity that could propel us toward a fuller realization of human potential.

The question is no longer whether these tools will change how we build software. The question is how willing we are, as developers, to change alongside them. Whether we realized it or not, that process was already underway. It is just that now, we cannot ignore it anymore.