What AI Reliability Actually Means
AI reliability has two halves: whether a model, LLM app or agent behaves correctly at runtime, and whether the code an agent writes survives production. Definitions, the SLIs to track, what uptime misses, and how to measure AI-authored changes.
ReadConnection Leak vs. Pool Exhaustion: How to Tell the Difference
Connection leak vs pool exhaustion: both end in the same timeout, but a leak ratchets in-use connections up until restart while exhaustion tracks load. How to tell them apart with pool counters and database sessions in Java, Node, Python, and Go.
ReadMissing Database Indexes in a PR: What Reviewers Should Check
A missing database index rarely shows in a diff: it hides behind a new filter, sort, join, or background job that passes tests on small tables. What reviewers should check, the EXPLAIN evidence to ask for, and how to add the index safely.
ReadN+1 Queries That Pass Tests but Fail Under Production Traffic
N+1 queries pass tests because a one-row fixture makes them look identical to correct code. Why they fail under production traffic, how to catch them with scaling tests and strict loading, and how to fix them without over-fetching.
ReadNode.js Memory Keeps Growing in Production: A Step-by-Step Investigation
When Node.js memory keeps growing in production, the raw graph is not proof of a leak. Learn to read the post-GC heap floor, find which memory layer grows, compare three heap snapshots, and follow the retainer chain to the code.
ReadResource Leaks in Java Services: Connections, Streams, Threads, and Executors
Java resource leaks exhaust pool slots, file descriptors, and threads long before the heap looks unhealthy. See how to spot the counter that ratchets with uptime, trace it to code, and fix connections, streams, threads, and executors for good.
ReadRace Conditions That Only Appear Under Production Load
Race conditions that only appear under production load come from hot keys, longer read-to-write windows, retries, and replicas that tests never create. Learn how to reproduce an intermittent concurrency failure on purpose and remove it with atomic updates.
ReadWhy “Check Then Insert” Creates Duplicate Records
Check then insert creates duplicate records when two requests pass the existence check before either one writes. Learn why transactions and SELECT FOR UPDATE miss it, and how unique constraints, upserts, and targeted locks fix it.
ReadSQS or Kafka Message Processed Twice: Designing Safe Consumers
An SQS or Kafka message processed twice is normal at-least-once delivery, not a broker bug. See how visibility timeouts, crashes, and rebalances cause duplicates, and how to build idempotent consumers that stay correct.
ReadDead-Letter Queue Keeps Growing: Where to Start
A dead-letter queue that keeps growing is a symptom, and redriving first usually refills it. Learn to read the growth shape, sample messages safely, classify the failure, and redrive only after the cause is fixed.
ReadAPI Timeouts After Deployment: A Practical Triage Checklist
API timeouts after deployment need mitigation first and diagnosis second. This triage checklist shows when to roll back, how to find where the time goes, and how to separate new code, resource starvation, contention, shared causes, and config drift.
ReadHow to Set Timeouts Across a Chain of Microservices
Timeouts across microservices only work when they are nested and each hop gives up before its caller. Learn how to build a timeout budget from the edge inward, propagate deadlines over gRPC or HTTP, and fit retries and fan-out inside it.
ReadCircuit Breaker vs. Retry vs. Load Shedding: Which Failure Needs Which Control?
Circuit breaker vs. retry vs. load shedding is a question about the failure, not the pattern. Learn which control fits a brief blip, a failing dependency, or an overloaded server, and how to combine them without making an incident worse.
ReadStale Data After a Release: How to Debug Cache Invalidation
Stale data after a release usually means a cache the new code no longer invalidates. Find which layer answered (CDN, Redis, per-pod cache, replica), then the write path, key change, or evict-before-commit race that broke invalidation.
ReadA PR Passed CI but Broke Production: What Did the Tests Miss?
When a PR passed CI but broke production, the failure usually lives in something CI does not model: real data, volume, concurrency, config, dependencies, or deploy order. Classify the escape, then add the cheapest check that can see it.
ReadHow to Decide Whether to Roll Back a Release
How to decide whether to roll back a release during an incident: check that impact started with the deploy, that the old version can run on data the new one wrote, and whether a flag or traffic shift is a narrower lever.
ReadHow to Write an RCA That Connects the Trigger, Code Path, and User Impact
How to write an RCA that reads as a causal chain: the trigger, the code path that turned it into a failure, and measured user impact. Includes a copyable root cause analysis template, a worked example, and action items that break a named link.
ReadAI Code Review False Positives: How to Verify a Reliability Finding
Most AI code review false positives on reliability come from context outside the diff. Verify a finding in six steps: restate the claim, check library semantics, reachability, and guards elsewhere, then link the evidence that settles it.
ReadWhat a Repository-Wide Review Finds That a PR Diff Misses
A PR diff shows changed lines, not the callers, shared config, and sibling code that decide whether they are safe. What a repository-wide review finds that a PR diff misses, and how to classify new, activated, and pre-existing findings.
ReadShould a Reliability Finding Block a Merge? A Severity Framework
Should a reliability finding block a merge? Only when the PR owns it, the evidence checks out, and its severity is high. A four-level framework for block, override, warn, or track, with overrides, CI enforcement, and a report-only rollout.
ReadHikariCP “Connection Is Not Available, Request Timed Out”: How to Find the Real Cause
The same pool timeout comes from a leak, a slow query, a long transaction, a pool deadlock, a connection creation failure, or an undersized pool. The evidence that tells them apart, and the code paths to map before changing a setting.
ReadKubernetes OOMKilled: Memory Leak, Memory Limit, or Something Else?
OOMKilled tells you where a container died, not what used the memory. How to tell a leak from a load spike, off-heap or tmpfs memory, eviction, or a limit that is simply too low, and why your dashboard said memory looked fine.
ReadWhy an API Is Slow in Production but Fast Locally
The same code runs against bigger, skewed data, different plans, real networks, and real concurrency. A trace-first workflow for finding why an API or database query is slow only in production, from plan flips and N+1 round trips to pool, lock, and CPU contention.
ReadHow to Prevent Duplicate Webhook Processing and Duplicate Side Effects
Webhooks arrive at least once, so duplicates are normal; they become harmful when a handler ships, pays, or emails before it records the event. Insert-first dedupe, fast acks, idempotency keys on every side effect, and a PR review that finds the missing boundary.
ReadRetries Can Cause an Outage: How to Spot a Retry Storm Before Merge
A three-line retry decorator can turn one failing call into 27 once it sits on top of the gateway and client retries already there. The multiplication math, backoff with jitter, retry budgets and deadlines, and a checklist for reviewing a PR before merge.
ReadWhich Commit Caused the Production Incident? A Practical Investigation Workflow
Work from time to code: pin the first bad time, map it to deploy SHAs, list the commits in the window, and keep the PRs that touch the failing path. Then confirm the top suspect with a revert, a flag flip, or git bisect run.
ReadProduction Readiness Checklist for a Backend Service
A free, downloadable production readiness checklist for backend services: 51 checkable items across ownership, observability, reliability, dependencies, data, security, deployment, capacity, and runbooks, each with why it matters and the evidence to ask for.
ReadHow to Review a Pull Request for Production Reliability Risks
Most incident-causing pull requests were reviewed and green in CI. A production code review checklist for spotting changes to resource use, failure handling, and downstream load in a diff, with an annotated example and a PR template.
ReadHow to Correlate Logs, Traces, and a Code Change During an Incident
A failing request, a pile of logs, and today’s deploys only connect through shared keys. Put trace ids in logs, stamp the git SHA into service.version, and follow the join chain from error to pull request to blast radius.
ReadCache Stampede: Why a Healthy Cache Can Overload Your Database
A hot key expires, hundreds of requests miss at once, and the database runs the same query hundreds of times. How to prevent a cache stampede with single-flight, Redis SET NX PX locks, TTL jitter, soft TTLs, and XFetch.
ReadWhat Is Production Reliability in Software Engineering?
Tests passing, CI green, and review approved each answer a narrower question than production does. What production reliability means at the level of a single change, and how it differs from DORA, error budgets, code review, and observability.
ReadProduction Reliability vs Code Review
Code review asks whether a change looks correct. Production reliability asks what it could mean for a running system. A small, correct diff to a shared library shows why you want both answers.
ReadProduction Reliability vs Observability
A system can be fully observable and still ship a change nobody assessed. Where dashboards, logs, and traces stop, where change level reliability starts, and the feedback loop between them.
ReadProduction Reliability vs Static Analysis
A change can compile, pass every rule, and still sit on a critical path with a history of incidents. What static analysis sees, what it can't see from source alone, and where the two meet.
ReadHow to Assess Production Reliability Before Deployment
A pull request can pass CI and review and still cause a production problem. Six areas to assess before deployment, scope, dependencies, verification, production behavior, history, and rollback, and how to turn uncertainty into an action.
ReadHow to Measure Software Change Reliability
There's no universal formula for the reliability of a single change. Seven signals you can measure before and after deployment, where a summary score helps, and what makes a reliability measurement trustworthy.
ReadPre Merge Reliability Analysis: How to Evaluate a Change Before Merge
Tests, static analysis, and review answer different questions. How to judge a change's scope, dependencies, production behavior, history, and blast radius while you can still change it, split it, or hold it back.
ReadHow to Assess the Blast Radius of a Code Change
A two line change to a shared library can reach dozens of services. How to map dependencies, production usage, history, and deployment conditions to see where a change can travel before it merges.
ReadHow to Identify High Risk Pull Requests
A five line change to a shared auth library can deserve more scrutiny than a 500 line change to an internal tool. Ten signals that separate high risk pull requests from routine ones.
ReadHow to Prioritize Risky Pull Requests
Diff size is the easiest signal and the least useful one. How to weigh impact, evidence, uncertainty, and deployment control to decide which PRs need more attention, and what to do about each.
ReadChange Risk Management in Software Engineering
Software changes create risk because they change something already running. The signals that matter, a practical workflow, and why the response should match the evidence rather than the diff size.
ReadThe Best Code Review Tools for Distributed Teams
Four layers, four different questions, AI review, reviewer routing, merge automation, and production risk analysis. Most comparisons treat them as one category, which is why they produce a ranking that doesn't help you choose.
ReadHow to Evaluate an AI Governance Layer: A Buyer's Checklist
Seven questions to ask any vendor, including us. Where in the lifecycle the decision happens, whether it explains why, whether it survives being wrong, and what it costs you to not have it.
ReadWhat Is AI Observability? A Definition for Engineers
An AI system can return 200 and still be wrong. What to capture across prompts, tool calls, retrieved context, and agent decisions, and the point where observability stops and a merge decision starts.
ReadLLM Observability Tools Compared: Datadog, Arize, and Langfuse
A large shared centre and three different edges. What each one actually tracks, which stack each one suits, and the question none of the three were built to answer.
ReadWhy Agentic AI Needs a Different Kind of Observability
A single LLM call has one output. An agent has a sequence of decisions, and the failure is rarely at the step where it became visible. Plus the gap between an agent's summary of its run and the logs of it.
ReadThe Best AI Evaluation Tools for Production in 2026
Evidently, Galileo, Arize, DeepEval, and OpenAI Evals, sorted by what a failing eval should actually do. Plus the six things a perfect eval score still doesn't tell you about shipping the change.
ReadWhat a Flaky Test Actually Costs You When AI Wrote the Code
A person sees a flaky test and investigates. An agent optimizing for “make the suite green” can retry it, weaken the assertion, or delete it. Three routes to green, and the build status looks identical for all of them.
ReadThe Real Risk of AI Coding Assistants
Token spend is easy to instrument, so it gets a dashboard. Revert rate, review time, and incidents traced to agent runs are harder, so they don't. What to measure on the other side of the ledger.
ReadThe Postmortem Template for Incidents an AI Agent Caused
A free template built on the standard postmortem format, plus the fields you need when an agent made the change, execution path, tool-calling trace, human checkpoint, and whether the agent's own account matches the logs.
ReadCode Review Automation Fixed the Wrong Problem
Time remaining in code review is up 441.5% year over year and PRs merged with no review at all are up 31.3%. Automating a comment is not the same as automating a review, and the constraint was never the comment.
ReadThe Code Review Observability Checklist Most Teams Skip
Pulling production signal into a PR comment is a good instinct. The pitfalls show up after the demo, stale service maps, one-way sync, alert-shaped noise, attribution collisions in a monorepo. Six things to verify before you turn the integration on.
ReadAI-Generated Code Needs a Different Kind of Pre-Screening
Code review assumed a human wrote it. AI-generated code fails differently, confident, clean, and plausible right up until it isn't. What pre-screening has to catch, why it's a different job from review, and why the teams getting this right review unevenly on purpose.
ReadMTTR Is the Wrong Number to Stare At
MTTR tells you how long an incident lasted, not why it happened or whether the fix addressed the cause. Faster rollbacks make the dashboard look great while the same class of bug keeps resurfacing. What automated root cause analysis has to do to be worth anything, and the metric that beats MTTR: recurrence.
ReadStop Having Your Customer Find Your Bugs
A validated study on the open-source Supabase repository: Tomosu produced 114 reliability findings, and 59 corresponded to defect classes already documented in public GitHub issues. Cron was the most failure-concentrated feature, three merged fixes for one header-handling bug over three months. Evidence that blast radius, not line count, should decide what a change must prove before it merges.
ReadThe Missing Layer in Modern Software Engineering: AI Governance
Every wave of software delivery removed a bottleneck, cloud, CI/CD, observability, AI coding. AI removed the last one. What is left is the confidence to govern the output. Software Governance is the new category above the pipeline: it orchestrates every tool's intelligence into one production decision.
ReadA Signal Is Not a Gate
Harness acquired Codecov to turn coverage into enforceable decisions. The problem: a signal and a gate are structurally different objects, and no acquisition closes the gap. The next decade of software delivery hinges on getting clear about which is which.
ReadNew Relic May See It. Tomosu Will Decide It.
New Relic launched AI Coding Observability and confirmed what the merge-gate category has been arguing for a year. Visibility is half the answer. Tomosu has been building the other half.
ReadProduction Resilience Is the Thing You Stopped Buying When You Bought Velocity
The velocity dashboard looks great. The on-call rotation is on fire. These two things are now happening at the same time in roughly every enterprise that has adopted autonomous coding agents at scale.
ReadWhen the Agent Has an OS and Production Has No Gate, the Gate Is the Product
RTX Spark and Bedrock AgentCore ship substrate governance. The harder problem is what governs the artifact after it crosses a boundary. Every substrate converges at one universal layer: the merge gate you own.
ReadThe Verification Debt Nobody Put on the Balance Sheet
AI agents now initiate 96% of the work in collaborator-driven repos. Almost none of it is governed by anything other than a human glancing at a diff. The gap between those two numbers is where risk quietly accumulates.
ReadThe Agency-Governance Split Is Real, and the Audit Trail Wasn't Designed for It
Agentic pull requests now constitute a substantial share of code authoring. Terminal merge approval remains almost exclusively human. The audit infrastructure most enterprises rely on was built before that split existed.
ReadTwo Halves of a Merge Gate, and the Layer That Sits On Top
Credo AI argues for policy-as-code upstream. Qodo argues for diff-aware analysis at the gate. Both are right. Neither captures the human governance decision itself, and that layer needs its own infrastructure.
ReadShift Left, Shift Right, and the Governance Layer Between Them
AI compressed both ends of the software lifecycle. The governance layer that holds the middle has not caught up. What that means for engineering, product, marketing, sales, and support in a SaaS company, and why the TCO case favours planning it in now.
ReadThe Merge Decision Has a Half-Life
A merge gate governs one moment. Drift measures how far production has walked from the gate since. Every merge decision has a half-life, and making that aging visible is the next layer of governance.
ReadNo articles match that search.
