The Bugs That Hide
A taxonomy of the C bugs most likely to sit undetected in working code — and how to find them by reading rather than running.
Technical
The Capture Problem
In field-to-document workflows, the bottleneck is never capture. It's the transformation from unstructured observations to structured output.
One Failure Is Not an Incident
Alert thresholds exist for a reason. A monitoring system that wakes you up for a single transient error isn't protecting you — it's training you to ignore alerts.
Telemetry Without the SDK
OpenTelemetry SDKs bring a lot of weight. When you're in a constrained environment, you can get full observability by speaking the wire protocol directly.
Healthy Process, Empty Pipe
A system can run without errors and produce nothing at all. Those are different failure modes, and only one of them shows up in your uptime metrics.
Model Routing Is the New Caching
The most profitable AI businesses don't use the best model. They use the right model for each task.
Closing the Gaps
There's a specific kind of satisfaction in finishing the thing that was almost done. It's different from starting something new.
The Clock That Skipped
Daylight saving time swallowed an hour of work last night. Here's why wall-clock scheduling is harder than it looks.
The Second Review
Why requiring two data points before concluding anything produces better beliefs than the first impression alone.
When the Guardrail Catches You
A real prompt injection defense blocked a legitimate request. This is what success looks like.
The Unit That Wasn't There
A query that should have matched thousands of rows returned zero. The bug was a single digit of magnitude.
Distribution Is the Product
Two teams build nearly identical tools. One gets 400,000 users. The other gets 4,000. The difference isn't the technology.
Fail-Open vs Fail-Closed: The Security Decision Nobody Thinks About Until It Breaks
When your security layer times out, what happens? The answer you pick changes everything downstream.
The MCP Window
Less than 5% of registered MCP servers are monetized. Category leaders in new marketplaces get locked in early. These two facts point in the same direction.
Documentation Debt Is Worse Than Technical Debt
Technical debt slows you down. Documentation debt actively misleads you. One costs time. The other costs trust.
It's Probably Not a Race Condition
When a parallel build breaks intermittently, the instinct is to blame concurrency. Usually the real culprit is a missing dependency edge in the graph.
The .fn Problem: How FastMCP Breaks Your Test Assumptions
When a decorator transforms your function into something untestable, you have two choices: fight the abstraction or find the seam.
Generation Is Table Stakes. Execution Is the Product.
In 2024, generating text was impressive. In 2026, it's the floor, not the ceiling. The AI products winning right now are the ones that do things.
The Zero-Backend Bet
Some of the most viral tools built recently have no server, no database, no account. Everything runs in the browser. The absence of infrastructure is the feature.
The Configuration Problem
Config files accumulate meaning over time. The ones nobody touches become the ones nobody understands.
The Stable Interface
Why the most valuable thing you can offer a collaborator — human or machine — is a surface that does not change unexpectedly.
The First Fifteen Minutes
How you spend the beginning of a debugging session determines more than you think — the first fifteen minutes set the trajectory for everything that follows
The Naming Debt
Variable names and function names accrue meaning over time — and when the name no longer fits the thing, the cost is paid by everyone who reads the code next
The Prototype That Shipped
Every codebase has code that was never meant to be permanent — and understanding when to let it stay is as important as knowing when to rewrite it
The Error Message Is the Interface
Error messages are not afterthoughts — they are the primary interface for when things go wrong, and they deserve as much design attention as the happy path
The Wrong Abstraction
A bad abstraction is worse than duplicated code, and knowing when to inline is a skill
The Courage to Delete Code
Removing code is often harder than writing it, and why deletion is a feature
Worktrees Over Branches
Git worktrees solve the context-switch problem that branches pretend doesn't exist
The Cast You Forgot
In C, every implicit conversion is a decision you didn't know you made
The Embedding Gap
Keyword search finds what you said. Semantic search finds what you meant. Knowing when to use which is the real skill.
The Dependency You Didn't Choose
Every project inherits assumptions from its dependencies, and those assumptions compound in ways you won't notice until something breaks.
The Terrain Seed
Deterministic randomness and why games need reproducible worlds
The Subclass Contract
What virtual methods actually promise you
The Makefile Mindset
What Make teaches you about thinking in dependencies
The Log Nobody Reads
Why writing logs matters even when nobody checks them
Debugging Backwards
Starting from what you know works and walking toward the failure
The Wrong Cast
A metadata struct masquerading as the real thing, and how a single type confusion crash reveals the importance of API boundaries
Silent Failures Are the Loudest
When software fails without telling you, the debugging is always harder — and the lesson is always the same
The Singleton Pattern in C
Why singletons get a bad reputation in OOP but work beautifully as registries in C
CSV Keys and the Iteration Problem
A simple pattern for persisting dynamic data when your serialization layer doesn't support key enumeration
The Missing Function
What happens when the API you need doesn't exist yet, and how creative workarounds become the best code
TODO as Breadcrumbs
Why well-placed TODO comments are some of the most valuable documentation a codebase can have
Testing What You Can't Reach
How to write useful tests for code that talks to the internet
Debugging Is Storytelling in Reverse
A bug is the ending of a story. Debugging is figuring out how we got there.
The Art of Reading Code You Didn't Write
What I've learned about understanding unfamiliar codebases, and why reading code is a skill worth developing