Articles
79 of 79 published pieces
Filter by topic
Latest
Gall's Law
A complex system that works evolves from a simple system that worked. What that means for the code and for the team building it.
- engineering-practices
Continuous Delivery vs. Continuous Deployment
The difference between keeping software releasable and automatically deploying it, and why readiness deserves deliberate practice.
- engineering-practices
3 min read
Code Entropy and LLMs
Why code entropy degrades LLM-assisted development and why model improvements won't fix it.
- AI
- engineering-fundamentals
- architecture
8 min read
Lehman's Laws of Software Evolution
Eight empirically derived laws that describe how real-world software systems change over time.
- engineering-fundamentals
5 min read
Lost in the Middle of an LLM Context Window
A large LLM context window tells you how much can fit, not how reliably the model will use information at every position.
- AI
- engineering-fundamentals
4 min read
TDD Doesn't Work for LLMs
Uncle Bob's Three Laws of TDD solve for human speed, not correctness. LLMs have the same flaws but a different cost structure.
- engineering-fundamentals
- AI
- engineering-practices
5 min read
Falsifiability for Engineers
Why the most valuable engineering claims are the ones that can be proven wrong, and how to make yours worth something
- engineering-fundamentals
5 min read
Shared Maps Beat Diverse Maps for Execution
Why teams with aligned mental models ship faster and how to keep that alignment from going stale
- leadership-fundamentals
- leadership-practices
7 min read
Manage Workflow, Not Tasks
Why managers should optimize flow through the system instead of maximizing local task activity.
- leadership-practices
4 min read
English Is Not Specific Enough for Code
We spent fifty years building languages to escape the ambiguity of English, and then we volunteered to go back.
- AI
- engineering-fundamentals
7 min read
Comprehension Can't Be Reduced to the Artifact
Peter Naur argued in 1985 that programming isn't about producing code. It's about building a theory of how problems map to solutions.
- engineering-fundamentals
6 min read
Head Metrics vs. Tail Metrics
Head metrics measure activity. Tail metrics measure outcomes. Only one resists Goodhart's Law.
- leadership-practices
4 min read
Separate Structural Changes from Behavior Changes
Every change is either reshaping the code or changing what it does. Mixing them together is one of the most common sources of unnecessary risk.
- engineering-fundamentals
6 min read
The Purpose of Abstracting
Good abstractions create new semantic levels where you can be absolutely precise, not vague wrappers that leak implementation details.
- engineering-fundamentals
6 min read
The Four Accelerate Metrics
Lead time, deployment frequency, mean time to restore, and change fail percentage measure what actually matters in software delivery.
- leadership-practices
11 min read
Goodhart's Law
When a measure becomes a target, it ceases to be a good measure
- leadership-fundamentals
6 min read
Some Architectures Work Better with LLMs Than Others
Architectural patterns that emphasize code locality work better with LLM-assisted development than patterns optimizing for shared abstractions.
- AI
- engineering-practices
7 min read
AI and Software Engineering: Iteration Compression, Not Revolution
AI has compressed the iteration cycle, not transformed the discipline. The constraint was never writing code. It was always understanding.
- AI
- engineering-fundamentals
- leadership-fundamentals
16 min read
Jevons Paradox and Software Engineering
Every efficiency gain in software's 70-year history has expanded the industry, not contracted it. AI follows the same pattern.
- leadership-fundamentals
6 min read
The Value of Software is in Its Optionality
Why software's real value lies not in what it does today, but in what it allows you to do tomorrow when circumstances change
- engineering-fundamentals
- leadership-fundamentals
6 min read
Test Behavior, Not Implementation
Why tests coupled to implementation details prevent refactoring while behavior-focused tests enable confident change
- engineering-practices
5 min read
Tasks Are Promises, Not Requirements
Why lightweight kanban tickets enable agile adaptation while detailed upfront requirements create the same friction they replaced
- leadership-practices
5 min read
In Order To
How two simple words can reveal whether your team's practices are serving a purpose or just going through the motions
- leadership-practices
6 min read
Why I Prefer One Week Sprints
How shorter sprint cycles with protected time and built in recovery enable sustainable velocity through reduced WIP
- leadership-practices
5 min read
The Case for Shorter Feedback Cycles
Why multiple formal frameworks from control theory to learning science all converge on the same conclusion about rapid feedback
- engineering-fundamentals
- leadership-fundamentals
5 min read
The Walking Skeleton
Using end-to-end integration to unlock parallel development and reduce work-in-progress
- engineering-practices
7 min read
Choosing an Architecture
A practical guide to selecting the right architectural pattern based on what actually changes in your codebase
- engineering-fundamentals
- leadership-fundamentals
7 min read
Freedom Is Not Chaos
How high functioning teams achieve freedom through deliberate constraints rather than the absence of structure
- leadership-practices
9 min read
Feature Flags
Understanding how feature flags separate deployment from release and enable safe, gradual rollouts in production
- engineering-practices
5 min read
The Daily Stand-Up
Understanding how daily stand-ups coordinate collaborative teams through strategy conversations, not status reports
- leadership-practices
6 min read
Control Flow Complexity
Why decisions buried deep in functions create complexity, and how pushing them to system boundaries creates simplicity
- engineering-fundamentals
8 min read
London vs Detroit Testing Styles
Understanding the two fundamental philosophies that shape how you write, structure, and maintain your tests
- engineering-fundamentals
7 min read
Pair Programming Is the Best Code Review
How pair programming achieves the theoretical minimum feedback cycle time by moving review into the implementation process itself
- engineering-practices
- leadership-practices
5 min read
Law of Triviality
Why teams spend more time debating trivial details than important decisions, and how to allocate attention more effectively
- leadership-fundamentals
2 min read
Single Responsibility Principle
Why SRP is about having one reason to change, not doing one thing
- engineering-fundamentals
5 min read
JSON Web Tokens
Understanding JWT structure, practical usage patterns, and critical security considerations for stateless authentication
- engineering-fundamentals
8 min read
Coupling and Cohesion
Understanding the fundamental forces that shape software architecture: how modules depend on each other and how well elements within modules work together
- engineering-fundamentals
6 min read
Immutability
Why objects that cannot be changed after creation lead to more predictable, debuggable, and thread-safe code
- engineering-fundamentals
5 min read
ACID Transactions
Understanding the four critical properties that database transactions must guarantee to ensure data integrity and system reliability
- engineering-fundamentals
6 min read
Interface Segregation Principle
How to design interfaces that are specific to their clients rather than general-purpose, preventing unnecessary dependencies.
- engineering-fundamentals
5 min read
Locality of Behavior
Design for understanding: code behavior should be comprehensible by reading only that code, not multiple files or abstraction layers
- engineering-fundamentals
5 min read
Microservice Architecture
Why microservices solve team coordination problems, not technical problems, and why most organizations would be better served by monoliths
- leadership-fundamentals
- engineering-fundamentals
6 min read
Dependency Inversion Principle
Why inverting dependencies is the key to flexible, maintainable software architecture
- engineering-fundamentals
7 min read
Little's Law
Mathematical foundation for understanding workflow: work in progress, throughput, and lead time are mathematically linked in every stable system
- engineering-practices
4 min read
Open/Closed Principle
How to design software that is open for extension but closed for modification
- engineering-fundamentals
5 min read
Lines of Code is a Bad Measurement
Why measuring productivity by lines of code is counterproductive and actively rewards what good engineering tries to eliminate
- engineering-fundamentals
3 min read
Never Nester
How avoiding deeply nested code structures reduces cognitive load and improves code readability
- engineering-fundamentals
6 min read
Richardson Maturity Model
Understanding the spectrum between simple HTTP APIs and truly RESTful systems through Leonard Richardson's four-level maturity model
- engineering-fundamentals
4 min read
Expressive Code
Why code should communicate its intent clearly to humans, not just execute correctly for computers
- engineering-fundamentals
5 min read
Ubiquitous Language
How establishing a shared vocabulary between business and development teams eliminates translation overhead and improves software quality
- engineering-fundamentals
- leadership-fundamentals
5 min read
Composition over Inheritance
Why building objects from smaller components creates more flexible and maintainable code than deep inheritance hierarchies
- engineering-fundamentals
2 min read
Idempotency
Why operations that produce the same result when repeated are essential for reliable distributed systems and fault-tolerant design
- engineering-fundamentals
3 min read
Law of Diffusion
How innovations spread through organizations and why technical excellence alone doesn't guarantee adoption
- leadership-fundamentals
5 min read
Tell, Don't Ask
Understanding how to maintain proper encapsulation by telling objects what to do rather than asking for their data
- engineering-fundamentals
5 min read
Brooks' Law
Understanding the counterintuitive principle that adding more developers to a delayed software project often increases the delay
- leadership-fundamentals
5 min read
CAP Theorem
Understanding the impossibility of simultaneously guaranteeing Consistency, Availability, and Partition tolerance in distributed systems
- engineering-fundamentals
5 min read
Constantine's Equivalence
Understanding the fundamental equivalence that shows why software costs are dominated by maintenance, not initial development
- engineering-fundamentals
- leadership-fundamentals
4 min read
Conway's Law
Understanding the fundamental principle that software systems mirror the communication structure of the organizations that build them
- leadership-fundamentals
5 min read
Law of Demeter
Reduce coupling by limiting object interactions to direct neighbors instead of reaching through multiple objects
- engineering-fundamentals
4 min read
Liskov Substitution Principle
How to ensure your code works with any implementation of an interface or base type, not just the original one.
- engineering-fundamentals
7 min read
The Calendar Crisis: How High WIP Creates a Meeting Trap That Destroys Throughput
Why everyone's calendars are impossibly full and how applying Theory of Constraints can break the meeting spiral by reducing Work-in-Progress
- leadership-practices
6 min read
The Hidden Cost of Agentic Development
Why AI code generation optimizes for the wrong variable and violates Constantine's equivalence about software economics
- AI
- engineering-fundamentals
- leadership-fundamentals
3 min read
The Hidden Cost of Timezones
How distributed teams multiply Work In Progress through timezone blocking, and why Conway's Law suggests aligning work allocation with communication patterns
- leadership-practices
4 min read
Build vs. Buy: Why Custom Solutions Win
Examining how the economics of custom development have shifted to favor building over buying for core business capabilities
- leadership-practices
- engineering-fundamentals
8 min read
Trunk-Based Development: The Path to Continuous Delivery
A data-driven exploration of why elite software teams are 160% more likely to practice trunk-based development and how it enables continuous delivery
- engineering-practices
- leadership-practices
5 min read
Verbs Over Nouns
How organizing code around behaviors instead of objects creates more maintainable systems and better aligns with business thinking
- engineering-fundamentals
6 min read
The Pursuit Of Predictable Projects
Exploring how work decomposition and continuous feedback can dramatically improve project estimation accuracy from 70% to 95%
- leadership-practices
6 min read
Architecture Is A Team Decision
Why software architecture decisions impact the entire team and how different architectural patterns affect development efficiency
- leadership-practices
- engineering-fundamentals
6 min read
Imperative vs Declarative Paradigms
A practical guide to understanding and effectively using both imperative and declarative programming approaches
- engineering-fundamentals
5 min read
Pull Requests Make Code Worse
A critical examination of pull requests in private repositories and why pair programming might be a better alternative
- engineering-practices
- leadership-practices
10 min read
Fibonacci Estimating
Understanding why agile teams use the Fibonacci sequence for estimations and how it matches human estimation capabilities
- leadership-practices
3 min read
DRY and SRP
Resolving the apparent conflict between Don't Repeat Yourself and Single Responsibility Principle in software design
- engineering-fundamentals
4 min read
SOLID In TypeScript
Practical examples and implementations of SOLID principles using TypeScript, with clear before and after comparisons
- engineering-fundamentals
6 min read
Agile and SOLID
An in-depth exploration of how SOLID principles enable agile teams to build maintainable, adaptable code
- engineering-fundamentals
- leadership-fundamentals
7 min read
Technical Debt
Understanding Ward Cunningham's technical debt metaphor and how to use it effectively in modern software development
- engineering-fundamentals
- leadership-fundamentals
3 min read
Theory Of Constraints
Understanding why improving anything other than your system's single constraint produces no improvement at all
- leadership-fundamentals
5 min read
Unplanned Work
How to identify, track, and systematically reduce unplanned work that disrupts sprint goals and team productivity
- leadership-practices
3 min read
Specifications VS Value
Contrasting waterfall's specification-focused approach with agile's value-driven development methodology
- leadership-practices
4 min read
You Are Always Wrong
Why assuming code will need to change leads to better software design and how to prepare for inevitable requirements changes
- engineering-fundamentals
3 min read