Complexity isn't an enemy

I recently came across Carson Gross's "The Grug Brained Developer". Well, actually, I found it through the design take of it, grug.design. Both are awesome and highly recommended reads. There are many things there I resonate with, but one that made me stop and think for a bit was "complexity is bad". So bad that if you needed to pick between a complex design vs. a sparring session with a T-Rex, you should go try to knock the T-Rex out.

But... I'm not sure I fully agree with that per se. The knee-jerk "simple good, complex bad" take definitely misses some nuance. Accidental complexity is certainly not awesome. But essential complexity is just a material reality. And I'd argue that it is not an enemy.

Complex isn't the opposite of simple

It's intuitive to think that something not simple is complex. But simplicity is also very much disputed. I don't think it's possible to fully generalize what makes something simple; it's contextual. And even simpler things can be complex.

Not all software is made equal, and some are just a bit more intricate and packed with functionality. To some extent, that makes them busier and more intricate. But it doesn't necessarily make them less simple. There is a simplicity gradient within all categories.

Think of programs like Blender, After Effects, Logic Pro, and even text editors. Software for professionals that often contains hundreds and hundreds of features, where you shouldn't try to slap all of them as icon buttons in a toolbar... even though some of them try (looking at you, Adobe). These are intense pieces of software, where learning them in-depth takes a lot of time and intention. You won't go through their main features in a three-step, carousel-like onboarding flow. And that's totally fine. The user experience should be consciously designed with that inherent complexity in mind.

Will users invest the time and effort to master them fully? Maybe not. And likely because of that, many will abandon them. But I've often seen people return to these tools because, ultimately, simpler alternatives just aren't as powerful.

Case in point

Many, many years ago, my parents were going through a months-long course to learn Final Cut Pro 7. I vividly remember that UI and how tough it was. Not easy to use at all, but very, very powerful. There was a reason why they were using Final Cut as opposed to just going for its simpler version (iMovie).

Over time, Apple obviously continued releasing more versions. These days, I think it is a pretty approachable software, honestly, even for non-video professionals. Probably because they managed to make it resemble iMovie in more ways. It feels simpler and easier to use. But it remains a complex application, where you need to dig around to access some less common features. And I'm pretty sure there might be multiple ways to accomplish a given task, which isn't inherently bad either.

I often see some pretty intricately-edited YouTube videos and then find out the author used Final Cut to edit them. It always gets me shocked because I don't understand how doing some of those things is even possible. There's so much you can do on it, despite it feeling like a much simpler program compared to its 2011 form.

Complexity can be organized

There's this concept of organized complexity that resonates with me in this context. Certain pieces of software inherently operate in tricky, feature-rich environments where complexity is imperative. But we can still organize it and help the user make sense of it.

Huge challenge, though. Not easy to conquer. It takes streamlining the number of existing patterns and making them feel more similar, including the way you hide initial complexity.

But it's a possible reality that accommodates and offers complexity in an approachable, progressive way. Battling against overwhelming users, but without oversimplifying things to the point where you sacrifice power.

I personally feel like this is one of the challenges over at Zed. Text editors can appear simple on the surface, but it's easy for them to become cluttered since there are simply too many possible actions. It's likely that 80% of users will need the more common features. But for the remaining 20%, hiding functionality away will probably drive them elsewhere. So, my challenge is organizing this complexity. Making the way you access things in Zed consistent and familiar. For example, switching between a local vs. remote workspace feels similar to switching branches. Accepting an inline LLM completion should be the same across multiple surfaces.

Wrap up

So, I don't think complexity is inherently a bad thing that we should avoid at all costs. It may be an inherent part of some systems, and our job as software designers is to manage it and present it in an understandable way. If a piece of software is extremely powerful, that capability may generate complexity, and we shouldn't try to eliminate that for the sake of simplicity.

There may be a tendency in modern design, partly because of B2C software, toward oversimplifying things. But that's not all software, and context and the type of job-to-be-done are fundamental aspects to always keep in mind.