Simplicity is an ever-present value of software development. It's been proven through years of software craftsmanship evolution that keeping things simple helps reason about problems easier, try out solutions faster, and deliver more value.
Sad to say, when junior engineers start getting more into thinking about problems and design, simplicity is not always the main director. We require them to explain—or at least try to explain—algorithmic decisions that prioritise optimisations over iterating through simple steps to prove they are worthy of a job. We require them to repeat design patterns that they don't fully understand, as a silver bullet for good design. We require them to guide us through years and years of design decisions in system design exercises to "implement Instagram feed" in 25 minutes.
Simplicity not only improves your work now when it comes to delivery velocity, cognitive burden, and code quality. It's also been clear that there are some clear advantages when it comes to prioritising simplicity in our industry vision.
Create a model that other people can understand and work on.
Code is a model. Like any model, it is a simplification of something bigger. For example: code for a banking application is not the bank. There are a lot more details of what's a bank and what it does (logistics, legal, etc) that your banking application mustn't consider to solve the problem it's designed to solve. So, like any model, you need to choose the right simplification of that true thing and focus only on the aspects and behaviours that matter for your case.
There's a point on "complexity as a cost of optimisation". Code is deterministically optimised for machines to understand (in most cases), so you don't have to worry about optimising it yourself, unless there's a non-functional requirement that your model is not achieving. Optimise for the engineers reading your code in the future.
Understanding a concept requires understanding its role in a system and its internal components and behaviours. This is backed by systems thinking. It's always better to approach your design with this in mind to reduce the cognitive load of working with your unit of knowledge.
KISS helps you manage more things in your head. Be proud of the simplicity of your code!
Prepare your code for working with more AI in the future.
It's been proven that AI tools work best in simple, modularised codebases over "codemesses".
AI struggles with being creative—it's always better to give it a clear example to follow. Having a clear separation of concerns in your codebase enables you to do just that.
The only certainty in the software industry around AI is that it's here to stay. It's not clear how the cost model will adapt, or the features it will provide, or what's the best way to integrate it into our workflows, but it's clear that we need to extend our readability concept to include best practices for AI to work with our codebase in the same way we think about humans interacting with it.