Complexity: The ugly of Software Evolution

Lexicon:

Capital refers to founders, owners, and stakeholders — the custodians of the means of production. In today's digital age, that production is software.

Note:

Yes, this is that cliché article — but it needs to be said. Again. Louder.

Statement

Complicated, as opposed to complex.
Do Run away from complexity like the enterprise's life depends on it. Because it does.

Complexity: Technical Symptoms

If you've been in the industry long enough, you've seen some of the following:

• A system becomes "too of a beast" — and collapses (or takes months to recover) the moment the original lead dev walks away.
• Development slows down, developers are anxious of their input in the construct. Bugs have been normalized.
• Code so complex that only one person understands it. That's not genius — it's design failure.

Complicated systems have many moving parts, but can be mastered with just mapping what's for what, and what stands where. Complex systems require constant adaptation. The architecture becomes fluid. Endless refactoring becomes the norm. When that happens, some tech lead failed. (Are tech lead necessary? Well that's another discussion).

Choose maintainability over brilliance.
It's not about you. It's about the social life of the software — which entertains the enterprise financial revenues. It's about the families and individual that it feeds, and feeds it, enabling their future. It's about that pocket of cultural value created by a community that bridges to social impacts. Tech with no humans is dead tech.

And no — software engineering is not about tooling. That's just obsessing over the shape and alloy of your sword and shield. Every era has its tools. Every era thinks it's special, with its tool and fashion. Don't embarrass yourself by name-dropping / name-splashing the hot stack of the year, the fashionable constructs. Most tooling that you use, you do not govern. It's just an add-on. It won't protect you from bad design.

Don't be impressed by complexity.
It's a red flag. The single marker that someone — or a group of people — doesn't know what they're doing.

Be impressed by beauty.
Be impressed by clarity.
The age of artistic extravagance has passed. Today, it's the era of noble and elegant minimalism. Restraint is the ultimate sophistication. In design — as in software — this isn't just about aesthetics. It's about intentionality. Minimalism doesn't mean doing less. It means doing only what matters, with absolute clarity and discipline. We've outgrown the ornamental baroque of cleverness. One should intent to design systems — and software — that are quietly powerful, unassuming, and long-lasting.

Look for the patterns, the unsaid, the internal jam. The shared cultural rhythm of a team that actually works together, not just sit next to each other. A team is a set of codifyed, patternized practices. A single force in motion through darkness. A collective wisdom, a collective brain that superseeds each of it's members cognitive faculties, and catapult their growth. It uses a common language. It's predictable practices makes it holy.

Architectural patterns exist for a reason: To reduce accidental complexity. It's proposed by humans to clarify, rather than obscure. Anyone should complicate a software architecture with the intent to ensure that any layers, component or parts, remains dumb and simple. Simplicity in the structural, the intent, the semantic. Separate concerns. Convention naming. Automate diagrams generation. Make intent obvious. Reduce cognitive load, especially for the devs who show up every day. Note that complexity scales non-linearly. What was manageable with 3 professionals becomes chaos with 30.

Look at any construct in Nature.
One would argue that every system has extreme simplicity at its core. I mean first principles thinking to a depth. The stunningly apparent complexity of evolved life forms is nothing but a misunderstood complicated. A gray cloud. With our cognitive layering not adapted to re-assemble it all and make sense of what is before our eyes. This translate to: "Wow, how does it ..?!". One would argue that humans are yet to dumb to Nature. We but Destructure. Let's pray AI helps us.

Complexity: Social Symptoms

Many of us chose engineering because we trusted our ability to handle cognitive load.

Cognitive load is a resource, and requires energy (even with AI). Time is finite. Life is training. Everything you build — internally or externally — is a reflection of your effort allocation. Be appreciative and thankful when discussing with someone else.

Some people are fast. You should praise that. I'm in "owe" frequently. It's fair to consider that that brain fast for certain things, and not for others. With this in mind, be carefull of the allure of cleverness. Don't be seduced by it.
Don't let anyone weaponize it. Don't let someone hide behind complexity — where they may use it to gatekeep or protect their seat.

The harsh truth: People have lives. They deal with ups and downs, biology, parenthood, visas, layoffs, dreams. They context switch (now naturallized in most modern layman software practices expectations). They forget. They leave. You can't build an organization around the assumption that the brain will always be available.

For a long time, raw problem-solving speed and similar forms of cleverness was the benchmark of engineering value. The core metrics. But that age has resolved. It's gone thanks to machine learning. LLMs now handle anything much faster and ++ depth abilities than most of us. Then what's the human metrics now? The human "plus-value"? (excuse my french).

From a Capital perspective: Every person should be replaceable. That's not cold — that's resilience. Complexity is the opposite of what capital wants. If your colleage isn't a great capitalist for the capital he works for, dumb it down. We never know what happens tomorrow. The systems need to be legible. You want people who make other people's lives simpler. (becarefull where harnessing our new digital people #AI agents).

For what it's worth, complexity is synonym to cancer in collaborative environments.

Further Reading

A Philosophy of Software Design by John Ousterhout — simplicity, clarity, and the death of accidental complexity.