I. What is Complexity?

Complexity can appear as a subjective notion difficult to clearly define, but if the scale of complexity varies some attributes contribute to increase it.

A. Core Definition:

Complexity corresponds to a high degree of interconnectedness, interaction, and refinement within a system or creation. It’s not just the number of parts, but how they relate and interact.

B. Key Characteristics:

• Adds up: Complexity tends to accumulate or “add up” over time.
• High number of components: It often involves numerous components and relationships that are difficult to track fully.
• Hard to understand: Complexity is often linked to a lack of understanding or a difficulty to grasp something easily. This difficulty to understand things can indeed be a side effect of the high number of parts and the high number of interaction between parts.
• Non-linearity: Complexity can quickly increase in an exponential manner.

C. Mental Model, complexity as a Boat

You can picture complexity as a boat. Like a boat increasing in size: it might become more robust or capable in some ways, but also less maneuverable, slower to change course, and requires more effort to operate.

D. Types of Complexity:

• Essential Complexity: Inherent to the problem being solved or the goal being achieved. Necessary for function or desired outcome (e.g., the complexity needed for flight).
• Accidental (Unrequired) Complexity: Introduced through specific choices, tools, poor understanding, or suboptimal design. This is the complexity we often aim to minimize. It adds burden without proportional benefit.

II. Why Does Complexity Matter? The Trade-Offs

A. The Benefits (Why we accept or introduce complexity):

• Often required to solve difficult problems or create more sophisticated/capable things (You can’t build a jet with paper plane simplicity).
• Enables advanced technologies and functionalities.
• Can lead to greater robustness or refined outcomes when managed well.
• Example: A programmable keyboard is initially complex to set up, but the benefit is enhanced long-term efficiency and personalization.

B. The Problems & Costs (The downsides):

• Time Consumption: Complex systems take more time to design, build, learn, use, modify, and troubleshoot. This is often the most significant practical cost.
• Reduced Understanding: Difficult to grasp how the whole system works (“Black Box” effect).
• Modification Difficulty: Harder and slower to change or adapt. Changes can have unforeseen ripple effects (due to tight coupling).
• Reduced Usability: Can be harder to use effectively due to the number of steps, options, or required knowledge.
• Increased Failure Points: More components and interactions mean more potential things can break or go wrong. Small issues can cascade. (Highly visible in software/technology).
• Hidden/Invisible Complexity: Systems can appear simple externally but have significant underlying complexity revealed only during use, maintenance, or modification. The relationship between actions and results may be unclear.
• Cognitive Load: Requires more mental effort to manage or interact with.
• Maintenance Burden: Requires ongoing effort to keep functional.

III. Where Does Complexity Come From? (Sources)

• Necessary Enhancement: Deliberate additions to improve functionality or processes (Essential Complexity).
• Poor Understanding: Lack of deep insight into the problem leads to convoluted, rather than direct, solutions (Accidental Complexity).
• Scale: As systems grow (more users, data, features), interactions naturally increase complexity.
• Integration & Interdependencies: Connecting disparate systems or tightly coupling components.
• Legacy Systems & Constraints: Building on or adapting to older, potentially less understood or flexible foundations.
• Accretion Over Time: Adding features/rules layer by layer without removing or simplifying older ones (e.g., tax code, complex software).
• Conflicting Goals: Trying to optimize for too many competing objectives simultaneously.
• Human Factors: Communication overhead, differing skills, organizational structure (Conway’s Law), tendency towards the “easy” path initially which might add long-term complexity.

IV. How to Handle Complexity

If you want to handle complexity first you need to ask yourself first if complexity is really a problem you want to tackle and what attribute of complexity you want to fight. - Do you want to make things easier to understand? - Do you want to simplify to make things more flexible, easier to change or less fragile to change? - Do you want to reduce the time burden that complexity create? Depending on what your goal are your strategy will be different.

Understanding how complexity evolves

Complexity is just the final result, the named concept. What we really need to understand first is how the different attributes of complexity evolves.

Understanding

-Ability to grasp how a system works quickly decrease when the number of active component increase and specially when those components have interdependencies.

Fragility

• Fragility increase when there is interdependencies, or when one component depends on severals components.

Strategies

Identify the pain points

Since what really matter is often to makes things easier to tackle a good proxy is to start identifying the pain point you encounter when you deal with the overall process. It will certainly makes emerges where high complexity lies. You will also be able to tight the pain point to one of the attribute of complexity.

Identifying dependencies and faillure

Faillure identification

• Identifies the dependencies between elements. How the faillure of one element affect others.
• Reduce chain of faillure.
• Set a system in place that clearly allow you to identify the point of faillure.

• If your system do not allow you to clearly identify point of faillure you will have hard time to figure it out by yoursel.

  Reduce the impact of failure

• Now that you understand how different failure of components can affect your system, you want to reduce the depencies between your elements.

• Create fail safe mechanism.

• If some of your components can fail without affecting the whole system, you system is less dependent and thus less complex to understand in some way.

  Segment the overall process

• Segment the overall process in smaller chunk to handle complexity at a smaller scale first.

  Segment the responsibilities

• Each module should be in charge of a single thing.

• You should easily know who is responsible of what.

  Create independent modules

• Create independent modules with their internal logic.

• Envision your modules as input/output box. For a given input you should always now what output to expect.

  Monitor your modules

• At anytime you should be able to know, what is entering in one of your modules and see what is exiting.

  Simplify

• A great way to reduce complexity is to remove steps in the process. If you can remove some steps of the process you limit the number of interactions that exist in your global system.

• Simplification is also about choosing between more simple alternatives.

  Document

• When you cannot reduce the steps or if adding steps is necessary you should be sure that you manage this complexity well.

  Automate

• Automating things allow to reduce the burden that numerous steps can have.

• To work well automation needs to have monitoring abilities and fail safe mechanism.

• Provide you a degree of control.

  Abstraction

• To makes things easier to control you can create layers of abstraction on top of your system.

  Building system with low complexity

• Identify the big parts of the system

• Work on each parts as modules

• Start with the default way of doing things. The most simple and then build from it.

• If you need to add steps always try to add clever solution that allows you to reduce complexityL

  A. Guiding Principles & Mindset:

• Focus on Value: Prioritize eliminating accidental/unrequired complexity. Does the added complexity provide proportional benefit?

• “Perfect is the Enemy of Good”: Avoid over-engineering; strive for effective solutions, not necessarily theoretical perfection.

• Start Simple: Begin with the most basic, default way. Test it.

• MVP Mentality / Gradual Refinement: Build a core solution first, then iterate and add complexity only where proven necessary and valuable.

• Compare Options: Explicitly weigh the complexity vs. benefit of different solutions.

• Focus on the Essential: Ruthlessly cut features or steps that don’t add significant value relative to their complexity cost.

• Less is More (Minimalism): Actively seek to remove the unnecessary.

B. Specific Strategies & Techniques:

• Understand the System (“Deconstruct the Black Box”): Map out components and interactions. Know how it works.
• Identify & Manage Failure Points: Use tracking, logging, testing, and redundancy to anticipate and mitigate failures.
• Abstraction & Interfaces: Hide internal complexity behind simpler, well-defined interfaces (e.g., APIs, car dashboard). Makes complex systems easier to use.
• Modularity & Decoupling (“Make things independent”): Break the system into smaller, independent modules with loose coupling. Limits ripple effects of changes or failures.
• Identify the Core System: Clearly define what the complexity is associated with.
• Understand Use Cases: Observe how the system is actually used (“revealed in doing”) to identify friction points caused by complexity.
• Standardization: Use common tools, patterns, and processes to reduce cognitive load.

V. Examples and Related Concepts

A. Examples Illustrating Complexity Trade-offs:

• Daily Life: Administrative tasks (bureaucracy).
• Technology Adoption:
  • Smart Home (potential benefits vs. setup, maintenance, failure points).
  • Integrated Home Hoovering System (marginal benefit vs. high maintenance/repair complexity).
  • Electric Window Shutters (convenient until battery fails/complex repair).
• Personal Systems:
  • Task Management (GTD) / Note-Taking (Obsidian): Powerful but risk becoming overly complex to manage.
  • Programmable Keyboard: Beneficial complexity once managed.
• Lifestyle/Projects:
  • Over-Gadgeted Hiking Backpack (feature complexity leads to weight/burden).
  • Cooking: Batch cooking (simpler logistics) vs. unique complex meals daily.
  • Overthinking (self-generated mental complexity).
• Technical: Infrastructure (databases, auth), Software Refactoring (Tinygrad example – actively managing complexity).
• Knowledge Management: Can become a time sink with low tangible output if over-engineered.

B. Related Concepts:

• Simplification : The active process of reducing complexity.
• Minimalism: A philosophy focused on removing the non-essential to reduce complexity and increase focus.
• Beautiful vs. Functional: Sometimes aesthetic choices add fragility or maintenance complexity (e.g., delicate wood floor in a bathroom).
• Costly vs. Functional: High-value items can introduce complexity in terms of security, insurance, and careful handling.