~ $ cd essays && cat *

Essays with more than half a million views

One every Saturday since 2022, on Medium, without missing one. More than 250 of them, in fourteen publications, read more than half a million times between them. Grouped here by what they are about, and within each group the ones Medium's members stayed with longest come first.

Testing

The subject most of them are about, and the one with the longest argument: that the industry's idea of a unit test is what makes tests fragile.

• Confirmed: Code Coverage Is a Useless Management Metric
  A simple proof that dismantles the metric every tech leader trusts.
• Two Disks: Code and Tests. You Can Only Save One.
  Rolldown threw away the code and kept the tests. Robert C. Martin's parable, solved.
• The Unit Test Trap
  Do you find your unit tests costly? You have fallen into the trap.
• QA-Unit Tests vs. Agile-Unit Tests
  How different agile testing is from traditional testing, and why the confusion costs so much.
• BDD is not E2E
  Why people confuse the two, and what BDD actually is.
• What Is Business Rules Coverage?
  Everyone knows code coverage. You may want to change your focus.
• Improve Your Testing #1: Play With Your Tests
  Turn testing into a game and see the hidden connections between code and tests. The first of nineteen.

Technical debt and legacy code

What the book is about, in pieces: never rewrite, never stop delivery.

• The Strangler Fig Pattern
  A pattern from 2004 that every developer should know: never rewrite from scratch, transform incrementally.
• Technical Debt Is Brain Debt
  Teams that stop refactoring may lose the ability to write clean code at all.
• Refactor All the Things All the Time
  Stop tiptoeing through the code; make it embrace the next feature.
• Improving Software Quality through Small Changes
  Not new developers, not more process: one chain reaction that tips the balance.
• We've Been Rewriting the Same Software for 70 Years
  Languages, architectures and paradigms changed. The applications did not. The limit was never the machine.
• The Craziest Piece of Software I've Ever Seen
  A library that made computers share memory by crashing on purpose.

Teams, agile and estimates

How the work actually gets done, against how the method says it does.

• Scrum vs Extreme Programming: Was XP Right All Along?
  Could the most popular methodology be the thing holding teams back?
• Asking for Estimates: The Telltale Sign of Ineffective Software Development Practices
  "When will it be done?" is the wrong question.
• If Developers Nail Estimates, They Are Lying To You
  Reliable estimates are read as maturity. Are they?
• Improve Your Story Breakdown
  The most effective agile technique, and the most overlooked.
• Stop Tracking Every Version Manually
  If you know which version is in production, you are not doing continuous delivery.
• This Simulator Shows What Meetings Do to Developer Productivity
  That 2 PM meeting just cost you the afternoon. Drag it around and watch.

Code, languages and architecture

The most read one is here, and the one that argues with Dijkstra.

• The JavaScript framework war is over
  And there is only one winner.
• Software Development Is A Beautiful Mess
  In 1968 Dijkstra banned GOTO, and he did it for the wrong reason.
• Coroutines, The Old Gem That Keeps Making Complex Code Simple
  A trick from the 1980s, right under our noses, that still untangles overlapping behaviours.
• What Are Micro-Frontends Really For?
  They got lost in the microservices hype; their real value is somewhere else.
• Domain-Driven Design Was the Key Piece Missing from My Computer Science Degree
  What finally connected requirements, design and code.
• React 19 Broke Update Stability, Keeping Half of Developers Stuck
  A two-stage update strategy should have prevented it. It did not.
• We're All Typing Commands Again
  Keyboards are back, and this time they are solving what the GUI never could.

Working with an AI

Since December 2022, from the angle of someone who tests things: what an agent is, what it costs, and what it does to the person using it.

• Context Engineering Makes AI Behave Like Software That Works
  Your agent does not run out of skill; it runs out of a clean context. Compaction, subagents, skills, RAG and guardrails, seen as one thing.
• A Tool Call Is Just Text and a Loop You Own
  Tool calling is a calling convention: the model writes a request, your code writes the result back. Real Ollama code, zero credits.
• An LLM Can't Keep a Secret
  It fails at hangman for a reason no bigger model will fix, and solving it shows what tool calls are really for.
• Don't Chat With Your AI. Mob With It.
  The chat loop makes you wait. Put the agent in a loop over your files, leave the instructions in the files, and run several at once.
• Tab, Tab, Tab: Copilot's Ticking Technical and Cognitive Debt
  Copy-paste on steroids removed the pain that made us better developers.
• Two Months of Pure Prompting Almost Ruined My Coding
  A week without Copilot showed what had been lost, and how to take it back.
• GitHub Copilot Code Review Is Probably Better Than Your Team
  It is not smarter. It is always available and paying attention.
• Your AI Is Not Your Intern. It's Your Senior, Junior
  An Anthropic trial, 52 developers, half with AI. The deciding factor was not AI versus no AI.
• The New Role of TDD in the Incoming AI Era
  December 2022: now that ChatGPT and Copilot are here, TDD matters more than ever.

In series

Some of them are courses in disguise: Improve Your Testing, in nineteen parts (2024–2025), and How to TDD with BDD-Gherkin, in six. And one essay grew until it became the book.