Writing
Articles
Field notes on intent-oriented development: gating AI-written code against intent with verify-diff, cross-language conformance, spec-driven workflows, requirements as code, and intent drift.
Test AI-Written Cursor Pagination for Skipped Records
Turn a pagination requirement into a checkable contract with tied timestamps, an executable acceptance test, and clear limits on what passing proves.
Test AI-Written Pagination Against a Tied-Timestamp Contract
Use a six-record fixture to test pagination order and cursor advancement, expose skipped timestamp ties, and understand what a passing test cannot prove.
Test AI-Generated PATCH Handlers for Omitted vs. Null Fields
Define omission, null, and string semantics, then test an AI-generated PATCH handler with four independent cases that check responses and persisted state.
Test AI-Generated Inventory Reservations for Partial Database Writes
Turn an inventory reservation requirement into a checkable contract with an injected database failure, committed-state assertions, and a success control.
How to Test AI-Generated Discount Code for Rounding Errors
Define a per-line rounding contract, catch a one-cent error with a worked example, and write acceptance tests that expose changes in discount behavior.
Test AI-Generated Ticket Creation for Duplicate Retry Side Effects
Turn an idempotent retry requirement into an acceptance test that checks both the returned ticket ID and persisted effects, then identify what a passing test leaves unverified.
Test AI-Generated Invitation Expiry at the Exact Boundary
Define an exclusive expiry boundary for invitations, test the production expiry gate with a fixed clock, and identify what those checks cannot establish.
Test AI-Written PATCH Handlers for Missing, Null, and Empty Values
Turn a partial-update requirement into a four-case contract that checks both the response and stored state, while keeping the limits of those tests explicit.
Multi-Agent Spec Handoffs: How to Keep Intent Intact Across Agent Boundaries
When one agent's output becomes another's input, intent erodes at every handoff. Here's how spec-driven verification closes that gap.
Spec Replay Regression: What Happens When an Agent Rewrites a Decision Already Made
AI agents that lack spec memory replay decisions your team already settled. Learn how spec replay regression silently reintroduces rejected behavior.
Spec Scope Creep: How AI Agents Silently Rewrite Behavior Outside Their Declared Intent
AI agents that pass all tests still drift into adjacent behavior. Here is how spec-scoped verification gates catch what code review misses.
Your Spec Should Be the Runbook: Intent Verification at Incident Time
When an AI agent responds to an incident, the spec becomes the only trustworthy record of intended behavior. Here's why that changes everything.
Spec Time vs. Runtime: Where Intent Verification Actually Breaks Down
AI agents verify intent at spec time, but runtime behavior diverges silently. Here is where the gap lives and why it matters for engineering teams.
Test-Time Reinforcement Learning Makes AI Code Smarter But Not More Spec-Conformant
Entropy-regularized policy optimization improves AI code generation quality at inference time. Here's why that still doesn't close the intent verification gap.
Machine-Verifiable Contracts: The Missing Layer Between a Prompt and Production Code
Most AI coding pipelines have no layer that checks generated code against what was actually asked for. Here is what that verification layer looks like in practice.
The Compiler Model for AI-Generated Software: Intent In, Verified Code Out
Treat an AI coding pipeline like a compiler: a well-defined input language, a deterministic verification pass, and a rejection path. Why that framing changes the architecture.
Spec Shadowing: When AI Agents Quietly Rewrite the Contracts Everyone Else Depends On
AI agents don't just write new code, they silently reshape shared contracts mid-task. Here's why that's an intent verification problem, not a code review problem.
EU Regulation of ChatGPT Is a Policy Problem. For Engineers, the Real Problem Is Unverified Intent.
The EU's DSA crackdown on ChatGPT exposes a gap engineers own: if AI-written code can't be verified against declared intent, regulation fills the vacuum.
AI Agents Don't Respect Service Boundaries Unless the Spec Says So
When specs stay silent on service ownership boundaries, AI agents treat them as suggestions. Here's why boundary intent must be declared, not assumed.
The Tacit Knowledge Problem: What AI Agents Cannot Inherit From Your Spec
Specs encode decisions, but not the reasoning behind them. Here's why implicit assumptions are the silent gap AI agents exploit, and how to close it.
Your Spec Is the First Thing an Incident Investigator Should Read
When AI-written code fails in production, the spec isn't a design relic, it's the evidentiary baseline that separates intent from implementation drift.
AI Agents Cover the Happy Path. Your Spec Has to Own the Edge Cases.
AI agents naturally optimize for the common case. Here's why edge-case intent belongs in your spec, not in code review comments.
Detecting Intent Drift Before It Ships: A Practical Framework
Intent drift is what happens when the code quietly stops matching the spec that authorized it. The detection patterns that catch it before code review does.
What the Stateless MCP 2026 Spec Means for Intent Verification Loops in Agent Workflows
The stateless MCP 2026 spec changes how coding agents communicate. Here is what that means for verify-diff loops and spec-gated AI code.