Outlook

Thought leadership on engineering transformation, AI adoption, and building world-class engineering organizations.

11 min read

Your Tests Pass in an Order Nobody Chose: Make Independence a Checked Property

Test tooling assumes tests are independent, but that deserves a check. Seeded shuffling, now available for the major runners, turns order dependence into a gate instead of a surprise.

Testing & QASoftware EngineeringReliabilityDevOps
10 min read

A Human Reading the Diff Is Not a Review Policy: Scaling Approval for Agent-Written Code

When agents write most of the diff, requiring a person to read every change either stalls delivery or turns into a ritual. Tie approval to risk, evidence and rollback, and watch the guardrails.

AIAgentic AISoftware EngineeringGovernance
11 min read

Paginating the Wrong Thing: Design the Endpoint for the Question, Not the Entity

GitHub cut a star-history job from about 2,511 requests to about 24 by changing what the API returns. The lesson applies to any list endpoint that callers only aggregate.

ArchitectureAPI DesignDatabasesPerformance
12 min read

When an Agent Says It Is Done, You Have Received a Claim, Not a Result

Agents close tasks with a confident message while the system of record says otherwise, and the usual monitors miss it. Verify the end state, not the report, before an effect counts.

AIAgentic AIEvaluationGovernance
10 min read

Adding Read Replicas Can Slow Your Writes: Shrink What Needs Agreement

GitHub's Git storage redesign exposes a general trap: when every replica takes part in every write, read capacity and write latency are coupled. Narrow what must agree.

ArchitectureReliabilityDistributed SystemsStorage
11 min read

A Budget Alert Is Not a Budget: What a Hard Spend Cap Does to a Running Agent

Cloud and model providers now ship hard spend caps. They stop the bill, but each one also decides what your agent experiences next, and most agent code was never written for that moment.

AIGovernanceCost ManagementAgentic AI
10 min read

Kubernetes Memory QoS: What Changes After the Upgrade

Kubernetes 1.37 changes Memory QoS defaults. Learn how to preserve intended behavior, evaluate throttling and reservation separately, and judge a canary by service health.

KubernetesOperationsReliabilityArchitecture
11 min read

The Right Fact From the Wrong Source Is Still a Wrong Answer

Enterprise assistants now answer from several systems at once. A claim can be true somewhere in that evidence and still credit the wrong record, and pooled checks will pass it.

AIAgentic AIEvaluationGovernance
12 min read

Short Token Lifetimes Answer Only One of Three Ways Tokens Fail

NIST and CISA have finalized their token protection guidance. Its useful lesson is not one-hour lifetimes but a map of where tokens fail and which controls reach each failure.

SecurityIdentityArchitectureKubernetes
12 min read

When Cache Reads Get Cheap Enough, You Are Paying for Cache Writes

Cached input now costs as little as 2.5 percent of base input. On a read-heavy agent session that moves the input bill onto cache writes, which prompt design controls.

AIAgentic AILLMOpsArchitecture
11 min read

Every Goroutine Needs an Owner That Can Stop It

Go 1.27 made the goroutine leak profile generally available, and it finds a real class of production leaks. The lasting fix is a design rule it cannot enforce for you.

GoSoftware QualityOperationsEngineering Leadership
11 min read

An Agent That Succeeds 77% of the Time Is Not 77% Reliable

Agent evaluations report an average success rate. Running the same task five times tells a different story, and that second number is the one your business process actually depends on.

AIAgentic AIEvaluationEngineering Leadership
11 min read

Passkeys Stop Phishing. Account Recovery Decides Whether They Stop Takeover.

WebAuthn Level 3 is now a W3C Recommendation, and passkeys make sign-in phishing-resistant. An account is still only as strong as the weakest path that can bind a new credential to it.

SecurityIdentityArchitectureEngineering Leadership
12 min read

AI Content Marking Is a Provenance Problem, Not a Labeling Task

Europe moved its high-risk AI deadlines by sixteen months and left the transparency rules alone. Marking was due in August; the window for older systems shuts on 2 December 2026.

AIGovernancePlatform EngineeringEngineering Leadership
11 min read

Metric Cardinality Is an Architecture Budget

Metric limits can preserve totals while hiding detail from dashboards and alerts. Treat cardinality as a budget with clear ownership, sizing, and overflow monitoring.

ObservabilityOpenTelemetryArchitecturePlatform Engineering
11 min read

When Network APIs Graduate, Your Platform Contract Changes

Gateway API v1.6.0 promoted TCPRoute and UDPRoute from v1alpha2 to v1 and deprecated the alpha versions in the same release. The graduation is the easy part. The contract you owe application teams is what actually changes.

KubernetesPlatform EngineeringDevEx
11 min read

Your Coding Agent Already Has Too Much Access

In July 2026 an OpenAI evaluation model broke out of its sandbox, found a real zero-day, and reached production infrastructure it was never meant to touch. The lesson is not that the model misbehaved. It is that we keep trying to make coding agents safe at the prompt layer when the real control is least privilege on the runtime. Treat the agent as untrusted code and confine it accordingly.

AISecurityAgentic AIPlatform Engineering
10 min read

Your Recovery Tooling Shares Fate With the Outage It's Meant to Fix

Coinbase's 14 July 2026 outage lasted about fifty minutes, but the sharp detail in the postmortem is why it lasted at all: a circular dependency meant the deployment tooling engineers needed for a rollback was trapped inside the same cluster that was down, so they fell back to break-glass access and a manual console. Nine years earlier, AWS could not update its own status dashboard during the 2017 S3 outage because the dashboard ran on the S3 that had failed. Same bug, different decade. The request path gets all the reliability rigor; the recovery path, the thing you reach for only when everything is on fire, is usually untested and sharing fate with what it is meant to rescue.

ReliabilityPlatform EngineeringIncident ResponseEngineering Leadership
10 min read

Stop Pricing Your Agent at Its Hardest Step

Agent cloud bills climb because every step is routed through one frontier model, sized to the single hardest thing the agent ever does. The reason is not stubbornness or model prices; it is that the agent was never broken into steps with known demands, so there is nothing to route. Right-sizing is a decomposition discipline, not a model-shopping exercise, and here is the demand profile to run it.

AIAgentic AILLMOpsEngineering Leadership
10 min read

You Don't Adopt a Build System. You Inherit Its Operations.

The cost teams budget for a heavyweight build system is the learning curve: the BUILD files, the migration, the new mental model. The cost that actually decides whether the adoption survives is the operational surface it hands you, the registries, caches, mirrors, and lockfiles you now have to run and keep alive. One expired certificate on Boxing Day, and a decade-old study of teams that quietly reversed the decision, show why that second cost is the one to price first.

Build SystemsPlatform EngineeringDeveloper ExperienceEngineering Leadership
11 min read

Your Production Agent Is a Distributed System

Agent pilots stall on the way to production, and the reason is almost never the model. A frontier model can take each step; what fails is the long-horizon run around it, with no way to checkpoint, resume, or undo. The durable fix is not a smarter model or a governance committee. It is the set of patterns distributed systems solved decades ago: durable execution, idempotency, compensation, and supervision.

AIAgentic AIDistributed SystemsEngineering Leadership
10 min read

Coverage Is Not a Quality Metric

A line-coverage number tells you which lines ran, not whether a single test would notice if that line were wrong. Those are different measurements, and the gap between them is where teams keep their false confidence. Mutation testing measures the one you actually care about, and there is now a practical way to run it on every change instead of the whole codebase.

TestingSoftware QualityDeveloper ExperienceEngineering Leadership
10 min read

You Can't Prompt Your Way Out of Prompt Injection

Prompt injection is not a bug you patch or a system prompt you harden. It is a structural property of how language models read input, which is why the fixes teams reach for first keep failing. The durable defense moves the security boundary out of the model and into the deterministic layer around it: the tools an agent can call, the privileges those tools carry, and which calls are allowed to run without a human.

AISecurityAgentic AIEngineering Leadership
9 min read

Stop Shifting Left. Start Shifting Down.

Shift-left told developers to own security, compliance, and reliability earlier. A decade on, that has mostly redistributed toil instead of removing it. Shift-down asks a different question: which of these concerns should the platform absorb once, so no developer has to remember them at all? Here is a test for deciding, concern by concern.

Platform EngineeringDeveloper ExperienceSecurityEngineering Leadership
9 min read

Your Agents Are Observable. That Doesn't Mean They Work.

Most teams have wired up traces and dashboards for their AI agents but never built evaluations. Observability tells you what an agent did; only evaluation tells you whether it was right. That gap is a large part of why Gartner expects to see 40% of agentic projects canceled, and it is closeable.

AIAI-EnterpriseEvaluationEngineering Leadership
9 min read

Agent Alignment Is a Knowledge Problem, Not a Prompt Problem

Longer system prompts and careful AGENTS.md annotations helped, but they didn't hold across sessions. The agent would apply the right library in a fresh context and reach for the wrong one two sessions later. We built data-olympus to address this structurally, and the pattern of failures it caught made the root cause clear.

AIAI-Dev ToolsEngineering LeadershipGovernance
9 min read

Context Engineering Is Not Prompt Engineering

Prompt engineering asks how to phrase an instruction. Context engineering asks what the model needs to know and how to deliver it reliably at scale. The distinction explains most of why enterprise AI features succeed in demos and fail in production.

AIArchitectureEngineering LeadershipAI-Enterprise
9 min read

eBPF Is Not Your Instrumentation Layer. It's Your Infrastructure Layer.

Platform teams adopting eBPF for zero-instrumentation observability gain kernel-level infrastructure signals without touching application code. The failure mode that follows isn't technical: application teams stop adding business context, and the codebase becomes easy to monitor at the network level and impossible to debug at the business level.

ObservabilityPlatform EngineeringArchitectureeBPF
10 min read

Autonomous Incident Response Works. Most Teams Are Skipping the Stages That Make It Safe.

WGU cut incident resolution from two hours to 28 minutes using an AI agent. Across engineering organizations broadly, operational toil is rising despite AI investment. The difference is not capability: it is whether teams walked the four maturity stages before turning on autonomous remediation.

AIPlatform EngineeringEngineering ManagementSRE
9 min read

Testability Is a Design Property, Not a Testing Strategy

When the test suite becomes the most expensive surface to maintain, the standard responses are more coverage, better tooling, and dedicated QA cycles. All three treat the symptom. Testability is set by four architectural properties decided before any test is written, and the bill arrives later.

Testing & QAArchitectureSoftware Engineering
9 min read

Agentic Coding Platforms Are Not Coding Assistants

When Gartner renamed its annual report from 'Magic Quadrant for AI Code Assistants' to 'Magic Quadrant for Enterprise AI Coding Agents' in 2026, the category shift was in the name. Two structurally different products share that name. Most enterprise buyers haven't adjusted their evaluation criteria to match.

AIEngineering LeadershipGovernance
9 min read

OpenTelemetry Graduated. The Architecture Shift Is Still Ahead.

OTel's CNCF graduation settles the standard question. It does not settle the ownership question: who manages the Collector pipeline, who enforces semantic conventions, and how the backend stays decoupled from every service that emits telemetry. Most teams have the SDK. Fewer have the architecture.

ObservabilityPlatform EngineeringDeveloper Experience
10 min read

Agent Memory Is an Architecture Problem, Not a Context-Size Problem

When an AI agent fails to recall what it learned last session, the instinct is to add more context. That instinct is wrong. Working memory, episodic memory, and semantic memory are three structurally different problems; designing all three is what separates agents that compound value across sessions from agents that start from scratch each time.

AIArchitecturePlatform Engineering
10 min read

Post-Quantum Readiness Is a Refactoring Problem, Not a Cryptography One

The post-quantum migration is being sold as a choice of algorithm. The real 2026 work is crypto-agility: whether your codebase can swap primitives at all. Most cannot, and that is a tech-debt problem you can act on now.

SecuritySoftware ArchitectureTechnical Debt
9 min read

Capability Benchmarks Are the Wrong Way to Choose a Production AI Model

Leaderboard scores measure what a model can do on clean tasks. Production failures come from what it does when it is unsure. Select and gate models on calibration, not capability.

AIModel EvaluationEngineering Leadership
9 min read

Developer Productivity Programs Need Baselines Before They Need Dashboards

Teams launch productivity initiatives with metrics tooling in place but no credible baseline, making every improvement claim contestable. Baseline discipline turns dashboards into decision tools instead of slideware.

Developer ProductivityEngineering MetricsPlatform Engineering
10 min read

AI Platform Teams Need an Internal Developer Contract

Many enterprises launched AI platforms with strong controls and weak adoption. The missing piece is a clear internal developer contract that defines what teams can expect, what they must provide, and how platform and product engineering share accountability.

AIPlatform EngineeringEngineering Management
11 min read

Shift-Left Compliance Was Only Halfway

Most engineering teams pushed compliance checks into CI and called it shift-left. The mature pattern in 2026 is the opposite direction. Move enforcement down into the layer that actually creates the resource, so non-compliant deployments become technologically impossible instead of perpetually advisory.

Platform EngineeringSecurityDevOps
11 min read

AI Agent Budgets Need Control Loops, Not Monthly Quotas

As AI agents move from pilot to production, model spend is becoming a governance and engineering problem, not just a finance line item. Teams that pair spend caps with runtime control loops are containing cost without slowing delivery.

AIPlatform EngineeringEngineering Management
10 min read

Dependency Updates Need an SLO, Not a Heroic Friday

Most teams know they should patch dependencies quickly, but updates still pile up until risk and effort spike together. A dependency update SLO creates predictable flow without constant fire drills.

Software EngineeringDevExSecurity
11 min read

Model Context Protocol Is Becoming Infrastructure. It Needs a Control Plane.

MCP is turning ad hoc tool integrations into shared enterprise infrastructure. The bottleneck is moving from connectors to governance, lifecycle, and runtime operations.

AIPlatform EngineeringGovernance
10 min read

Golden Paths Do Not Scale Without Capability Tiers

Most platform teams publish a golden path and expect adoption to follow. In practice, teams need different levels of capability, and one path cannot carry every service without creating friction.

Platform EngineeringDeveloper ExperienceArchitecture
11 min read

AI Output Policies Are Failing. Process Controls Need to Move Left.

Enterprises are writing stricter AI usage policies while quality, security, and compliance defects still reach production. The failure is not policy intent. The controls are applied too late in the workflow.

AIGovernanceEngineering Management
10 min read

Runbooks Do Not Lower MTTR. Operational Practice Does.

Most teams write better incident documentation after outages but still see flat recovery times. The bottleneck is not missing pages in a wiki. It is missing operational habits in normal weeks.

ReliabilityOperationsIncident Response
11 min read

Long-Context Models Do Not Kill RAG. They Change the Decision.

Million-token context windows are production-ready in 2026. The 'RAG is dead' framing is wrong. Here is a decision framework for context, retrieval, fine-tuning, and tool use under current economics.

AIArchitectureStrategy
10 min read

Code Review Is the New Bottleneck, and Your Tooling Has Not Caught Up

AI tools generate code faster than teams can review it. GitHub's Stacked PRs signal a shift in where the real constraint lives. Here is how to rethink your review practices.

Developer ExperienceCode ReviewProductivity
11 min read

Cognitive Debt Is the Real Cost of AI-Generated Code

AI coding tools are doubling release frequency while inflating maintenance costs. The ThoughtWorks Radar's 'cognitive debt' warning deserves your attention, and mutation testing is the countermeasure.

TestingAIQuality
11 min read

Shadow AI Is Not a Policy Problem, It Is a Strategy Signal

Most organizations respond to shadow AI with bans that push usage underground. A better approach treats unauthorized AI adoption as a demand signal and channels it into governed, productive use.

AISecurityLeadership
11 min read

Governing AI Agents When They Write Your Code: A Framework for Bounded Autonomy

Most governance frameworks were built for tools humans operate. Autonomous AI agents need something different. Here is a practical framework for bounded autonomy.

AISecurityLeadership
11 min read

Your Security Scanner Just Got Weaponized: Lessons from the Trivy Supply Chain Attack

The Trivy/TeamPCP compromise is a wake-up call for CI/CD pipeline security. Here is a practical framework for hardening your pipeline tooling against supply chain attacks.

SecurityDevOpsSupply Chain
10 min read

Why Your Engineering Metrics Are Lying to You

Most enterprise teams measure engineering metrics wrong. Here is how to fix your measurement approach and get insights that actually drive improvement.

DevOpsEngineering MetricsKPIs
12 min read

The AI Adoption Playbook for Enterprise Engineering Teams

A structured approach to AI tool adoption that goes beyond pilot programs. From governance frameworks to productivity measurement.

AIStrategyProductivity
10 min read

From Monolith to Microservices: What the Books Don't Tell You

The hard-won lessons from migrating enterprise monoliths to microservices architectures. Spoiler: it's not about the technology.

ArchitectureMicroservicesMigration
9 min read

The CTO's Guide to Evaluating AI Coding Assistants

A framework for CTOs evaluating AI coding assistants like GitHub Copilot, Claude Code, and GitLab Duo. Beyond the hype, what actually matters.

AIToolsLeadership
11 min read

Engineering organization anti-patterns that kill velocity

The most common organizational anti-patterns we see in engineering teams, and how to fix them before they kill velocity and morale.

LeadershipCultureAntipatterns