In a recent post, Paul Dix makes a case for “the end of programming.” Looking at the rapid evolution of AI agents and the massive, AI-driven Rust rewrite of Bun, he argues that the manual writing and line-by-line reviewing of code is headed for extinction. Instead, AI will generate an absolute deluge of software, with engineers stepping back to supervise the final results rather than the syntax.

That’s been a common theme lately, particularly since last November’s watershed moment in the capabilities of coding agents. This telling brought me back to a piece I wrote in 2019 and revised (with Dai) last year: Untangling your technology spaghetti.

In the original version of that post I noted that:

“Technology spaghetti” is what you get when your technology, data, commercial arrangements and operating processes get tangled up. It’s not just a problem of having too many pieces in the puzzle, it’s also that the interconnections between them are hard to understand and manage.

Eventually you reach a point where it’s difficult to introduce change, or even to be sure you can provide resilient services.

That just gets worse over time because when technology, data, commercials or processes are overly complex, the easiest thing to do when you want to do something new is to add yet another system. More stuff gets aggregated on top of old stuff. More spaghetti.

As time passes, things get worse still because people leave the organisation and understanding fades; unmaintained systems get forgotten; change gets harder.

There’s justifiable excitement that AI helps address that last set of issues. The achievements of the Government of Alberta in using AI to migrate legacy systems is one good example. But connecting these two realities reveals real tension. If the path of least resistance is what creates technology spaghetti today, how do we manage the competing paces of creation and transformation?

Dix rightly notes that alongside well-engineered software, AI will also produce a “mountain of slop”—buggy, unreviewed code that conforms to no architectural aesthetic. If we unleash autonomous agents into our infrastructure without fundamentally changing how we manage our technology estates, we could easily generate spaghetti at 100x the speed. We will go from deep digital geology to rapid digital landslides.

If “the end of programming” is truly upon us–or even just a massive explosion in who has access to partake in it–the nature of technical leadership must shift. Generating code is becoming a commodity; governing architecture is becoming a premium. The practices of “continuous untangling” will be the only things keeping organizations from collapsing under their own weight:

  • Mapping the sprawl: If engineers aren’t reading the code, living registers of what systems do and who owns them become your only anchor to reality.
  • Building flexible seams: We will need rigorous boundaries (API and otherwise) to isolate AI-generated systems, ensuring they can be swapped out, iterated upon, or broken without bringing down the core.
  • Paving the paths ever more clearly: Providing really robust platforms and AI skills that encode standards and make doing things the right way by far the easiest.
  • Mastering the art of stopping: When generating new code costs practically nothing, the most valuable engineering skill becomes decommissioning. Knowing when and how to ruthlessly prune dead threads of software will be the defining characteristic of an adaptable business.

The the era of writing code by hand may be fading. But the messy, human, strategic work of untangling? That is only just beginning.