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 tenant isolation before accepting a cache change
Use a two-tenant A–B–A test to check tenant isolation on the changed read path and confirm that the final response actually uses the cache.
A conflict response does not prove a stale write was rejected
Check persisted state after a stale update is rejected, then establish separately that version comparison and mutation are atomic.
Test queued email against consent at send time
Define a send-time consent contract, test an unsubscribe after enqueueing, and identify the race a passing acceptance test leaves unresolved.
Test whether approval survives a changed refund
Bind approval to an immutable refund snapshot, then test that changed requests are rejected before payment and unchanged requests still execute.
Test AI-Generated Cancellation Code at the Acknowledgment Boundary
Define what cancellation acknowledgment promises, then test it with a controlled race, a non-cancelled control, and explicit limits on what passing proves.
Test AI-Generated Cleanup Against an Event-Order Contract
Use a runnable event-recording fake to check connection ownership, cleanup order, and exception identity, without mistaking passing tests for proof of leak freedom.
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.
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.