In recent years, applications have become bloated and extremely complex. With the advent of Javascript frontend frameworks like React and Vue, we have essentially doubled or tripled the workload, by creating essentially two or more isolated systems for one application. 

This led to the insatiable demand for programmers that we saw until the start of 2023, with Musk’s mass lay off at X (formerly Twitter) and then shortly after Microsoft joining suit, these decisions coincided with the development and increased usage of AI, decision makers have mistakenly believed that this technology will replace the requirement for development resources. 

Applying this logic to new systems is reasonable, however most systems are legacy and legacy systems are a massive mess and complex interconnected systems, AI, therefore will only be able to empower a developer to be more productive upon such a system. The context required to understand and implement changes is currently beyond the technology. To be fair, for the larger legacy systems, it’s also beyond humans. 

However, the layoffs have already been done and the shift in progress and AI is nowhere near being able to plug the gap. So what’s the solution? Dramatically simplify systems.

I have been advocating for the past 4 years, the simplification of systems architecture and a zero-legacy approach. There's a sentence you don't see everyday, let's break it down. 

The issue of problems in a codebase, is not their existence, like an infection, it spreads. In code this happens when a bug, issue or archutectureal misdesign becomes a dependency of another piece of code. Once this happens, and more features become dependant the more difficult it becomes to remedy the problem.

An example would be you have a wrongly typed field in a database, you build your application constantly casting it to the correct one, after 2 years this casting happens in 500 places in your code and it’s now a mountain of a job to change because 500 hundred places are dependant on a misdesign. 

Zero legacy is development approach to ensure that you’re continually reducing the technical debt of you application. This happens by spending time fixing your code, before submitting a pull request, which removes problems before they even make it to the codebase. 

Instead of spending money on development and maintenance of separate frontends and backend, use one consolidated system. More importantly, shift your thinking from delivering all whimsical features to how much effort are we willing to expend to see a certain feature happen, if it’s over 90 days, simplify the feature. It would seems the age of an endless backlog has become to expensive to maintain. 

You might be thinking now that you need the functionality that is provided in these contemporary Javascript frameworks. Frankly, this hasn’t been true for a while now, we can achieve identical behavior with lightweight, packages like HTMX or Stimulus.js 

Alas, and yet, this shift of arcutrectual approach on all levels will take time to trickle down from the big players to smaller companies. But make no mistake, the wind of change is blowing.