75 posts, newest first — every part of every series, on its own.
The series finale: how SRE's management practices invented platform engineering a decade early. Training, interrupts, culture — and what the data says now.
Hermetic builds, canarying, the launch checklist's one brutal rule — and CrowdStrike 2024 as the lesson in skipping validation. Part 11.
Pipelines are distributed systems with a moiré problem; backups are a tax and restores are the product. Part 10 — with GitLab 2017 and Atlassian 2022.
See leader election, think distributed consensus — anything less is a ticking bomb. Part 9: quorums, split brains, CAP, and the double-launching cron.
How load balancing works, why 'queries per second' is a terrible metric, and the cascade loop that kills distributed systems. Part 8, with Fastly's 2021 outage.
ICS roles, the incident-state doc, the blameless postmortem, and the data layer that turns outages into improvement. Part 7, plus the incident.io ecosystem.
The hypothetico-deductive loop, 'triage first, root-cause later', and why negative results are magic. Part 6 — plus Meta's 2021 outage as the modern Diskerase.
The pager arithmetic behind on-call: 25% cap, two incidents per shift, and why operational underload is as dangerous as overload. Part 5, ten years on.
Latency, traffic, errors, saturation — and the rule that matters most: every page must be actionable. Part 4, with Borgmon's lineage to Prometheus.
Five principles for actually getting toil down, each with a real story — the automation ladder, the competence/latency/relevance tradeoff, and Diskerase.
SRE's key idea: 100% availability is the wrong target, and the error budget turns that into an incentive system. Part 2, with the burn graph explained.
Google's SRE book invented the error budget and blameless postmortem — most quote it unread. Part 1: what SRE is, and why the sysadmin model was doomed.
Architect vs. Gardener, PARA vs. evergreen notes — with a real Obsidian migration (487 links, 0 broken) showing why AI search favors one.
The effectiveness test for observability, why postmortems should measure MTTK, and the book's closing philosophy: enablement over control.
Where to start an OpenTelemetry rollout, how to migrate off OpenTracing without breaking the chain, and why auto-instrumentation always wins by default.
Head-based, consistent-probability, and tail-based sampling — three strategies with real math — plus the four places a Collector can physically live.
Receivers, processors, exporters, pipelines — how the Collector became observability's universal plumbing, and the OTLP protocol underneath it.
OTel doesn't replace your logging framework — it contextualizes it. Why the Logs API is experimental, and how trace IDs get into logs you already have.
Six instrument types, five aggregation strategies, and the cardinality mistakes that make metric backends fall over — OTel's metrics API, explained.
Spans, span kinds, async causality, and why fire-and-forget tasks silently corrupt your traces. The tracing chapter of Practical OpenTelemetry, with diagrams.
Traces span services — but who carries context between them? How OTel's Context API, Baggage, and propagators turn isolated telemetry into one story.
The fastest path to OpenTelemetry: attach an agent, get 122 libraries instrumented — zero code changes. When to customize it, when to turn it off.
Traces, metrics, logs, and baggage — plus the API/SDK split and semantic conventions that make OpenTelemetry a standard instead of just another library.
DeepSeek open-sourced its Claude Code rival and hiked V4-Pro pricing in the same week. Real code, a head-to-head comparison, and the plugin architecture.
DeepSeek Harness turned agent modes into directories, not classes — the design behind 300+ plugins in a day, vs. Claude Code's hardcoded agent types.
Instrument once, export everywhere: how OpenTelemetry merged two competing projects into one standard and changed what vendors actually sell.
How DeepSeek Harness gives one agent its own tools and persona without forking config — a running Agent object literally is its own registration key.
From tool/call to tool/result: the eight-stage pipeline DeepSeek Harness runs every tool call through, and why its guards can only say no.
The 3-role pattern behind DeepSeek Harness's ~85 capability seams — and why swapping local bash for sandboxed bash touches exactly one config row.
In DeepSeek Harness, model-visible means logged — a real runtime check on the session log that fails the request the moment log and model diverge.
What happens when DeepSeek Harness crashes mid-write — real JSONL/SQLite recovery code, and why compaction never rewrites the session log.
The real ~10-line waterfall() implementation that retry, compaction, approval, and every other policy decision in DeepSeek Harness quietly runs through.
Inside DeepSeek Harness's agent loop: a real, issue-numbered bug where a wake message could silently vanish during cancellation.
DeepSeek Harness's LLM adapter seam — one message shape, one streaming fold, and a retry counter that's derived from the log instead of kept in memory.
How DeepSeek Harness spawns, forks, and delegates to child agents — and keeps a strict line between what a child said and what the runtime reported about it.
DeepSeek Harness's real bwrap/Landlock/Seatbelt/Windows-ACL sandbox chain — and four dated production incidents, with root causes, that shipped and got fixed.
How a browser, a typed RPC client, and an external SDK all reach the same running DeepSeek Harness process through one generated RPC layer.
The real coverage gates, test philosophy, and contributor rules behind DeepSeek Harness — including why 178 green tests still missed a real production bug.
DeepSeek Harness vs. Claude Code, problem by problem — six ideas worth stealing, and a Guides-vs-Sensors lens for auditing either one.
How a running DeepSeek Harness process is assembled from YAML — profiles, bundles, patch layers, hot-reload, real code.
Your MTTR hides five separate clocks — the industry spent 20 years optimizing the wrong one. Why monitoring and observability aren't the same thing.
Karpathy's LLM talk, rebuilt with diagrams and primary sources — how models train, compress the internet, and become the kernel of a new OS.
AI doesn't let managers scale 5x with headcount — it shifts their time into coaching and judgment. Here's how AI-era performance reviews should work.
The 6–8 person team rule shaped modern engineering management. Here's why it's about to flip — and what AI agents mean for span of control and your role.
The book's closing playbook: build vs. buy vs. open source, how to run a vendor trial that actually proves something, and where observability goes next.
How to fund observability like a strategic bet, tell whether the money is actually working, and push real change past organizational resistance.
Why the real constraint on engineering teams in the AI era isn't how fast they can write code, but how fast they can understand what that code just did.
How production telemetry and evaluations form a learning flywheel for LLM applications — illustrated by Fin's real turnaround in speed, cost, and reliability.
Your build pipeline, your mobile app, and your cloud bill are all systems worth debugging the same rigorous way you'd debug a production outage.
How teams keep observability affordable at scale — smarter sampling, telemetry pipelines, and a shared vocabulary that keeps humans and AI agents honest.
How error-budget math actually decides when to page you, and why observability data needs a database that plays by different rules than metrics ever did.
Collecting telemetry is step one — here's how to investigate it, build it into your workflow, use AI agents wisely, and alert on what users feel.
Why the shape of the data you collect today quietly decides which questions you're allowed to ask tomorrow — and how OpenTelemetry lets you avoid that trap.
Observability has a precise, decades-old technical definition that most 'observability platforms' quietly fail to meet — here's what it actually requires.
Most managers accidentally make their teams dependent on them. These 7 coaching questions break that cycle — with real workplace scenarios for each.
One post of synthesis after eleven of principles: three questions builders should answer, twelve design lessons, and the practical kit to start.
The most expensive agent mistakes happen in the first few turns. Plan Mode is the architectural pattern that prevents premature action.
An agent taking 10 seconds feels broken even when correct. Streaming isn't just UX — it's an architectural choice. How to build agents that feel fast.
Single agents hit ceilings. Multi-agent systems hit coordination instead — the Fork pattern, the Coordinator pattern, and skills + MCP as the extension layer.
Customize agent behavior without forking the core: 26 lifecycle events, 5 hook types, and a security model that keeps extension from becoming an attack surface.
Every long-running agent eventually hits the context window ceiling. The four-level compression architecture that keeps agents running, not crashing.
Every session starts fresh unless you build a memory system. How to store what matters, skip noise, and extract memories without blocking the main loop.
Agent harnesses need a config architecture, not a flat file. How Claude Code layers settings across six stakeholder types — users, projects, enterprises.
Autonomous agents need guardrails without constant interruption. Claude Code's permission pipeline: safety that scales with risk — not a blunt on/off switch.
Without tools, an LLM can only produce text. The tool system engineering that turns Claude Code from a chatbot into an agent that acts safely and concurrently.
Every autonomous agent runs on a loop. Here's what that loop needs to do — and what Claude Code's implementation reveals about building one for production.
Most LLM apps fail because there's nothing holding the model together. Here's the architecture that makes autonomous agents work — the Agent Harness.
Build an autonomous travel planning agent in TypeScript — applying Claude Code patterns to a real React/Ink TUI that runs on Claude, Gemini, or Ollama.
Why one extension mechanism isn't enough. Learn the three ways Claude Code extends agent capabilities and when to use each one.
The complete playbook: Claude Code's 4-layer safety model and 10 design patterns you can steal for your own agentic system. The series finale.
Three memory problems every agent must solve: short-term state, long-term knowledge, and context windows. Learn Claude Code's elegant solutions.
How Claude Code's tool layer turns LLMs into agents that act. Learn tool design patterns, MCP integration, sandboxing, and principles for building your own.
Why Claude Code's simple while-loop beats complex graphs. Learn the master loop pattern, streaming, async queues, and how simplicity wins in production.
Claude Code's five-layer architecture decoded: ReAct pattern, context management, and design patterns you can steal for your own AI agents.
Claude Code isn't just AI autocomplete — it changes how you build software. Here's the mental model, strengths, pitfalls, and what you need to get productive.
