A Philosophy of Software Design
Central idea
Good design continuously reduces the amount of system knowledge a developer must hold in mind to make a safe change.
Summary
Software complexity is the difficulty of understanding and modifying a system. It appears as change amplification, cognitive load, and unknown unknowns; its underlying causes are dependencies and obscurity. The central design move is to create deep modules: small, stable interfaces that hide substantial implementation complexity. This requires strategic programming—investing a little time in design during everyday work instead of optimizing only for the next patch. Working code is not the finish line if every later change becomes harder.
Key ideas
Complexity is experienced by readers
Measure design by how much knowledge a developer needs, not by how clever or compact the implementation looks.
Hide decisions behind deep interfaces
A useful module absorbs difficult policy and exposes a simple mental model to callers.
Design is continuous
Small, repeated investments prevent tactical shortcuts from hardening into permanent structure.
Three warning signs
A small change touches many places.
Too much context is needed at once.
It is unclear what must change.
Why it matters now
AI can add code faster than teams can understand it. Designing for low cognitive load keeps generated and human-written code changeable over time.
Continue with the original
This short version preserves the main argument. Follow the source for the complete talk, article, or book.