AI coding agents
Claude Code, Cursor, Copilot, Devin, and multi-agent fleets generate code faster than review can absorb it. These essays cover how governance applies across coding agents, code review, and the agentic SDLC. Start with the guardrails field guide. Browse all insights.
What Happens to an Architectural Decision After Ten Agent Turns
Coding agents lose fidelity to earlier decisions as trajectories lengthen. 2026 benchmarks now measure the decay, and repository state alone does not survive a handoff.
Agent Governance in the SDLC: From a Generation Problem to a Governance Problem
Multi-agent orchestration moves delivery past single coding agents. Subagents parallelize execution and inconsistency — shifting software delivery from a generation problem to a governance problem.
Pre-Action Enforcement: Where Agent Governance Takes Effect
Review and CI see agent actions afterwards. Pre-action enforcement checks a proposed write first, but only on action paths the gate can reconstruct.
Package Hallucinations Show Why AI Coding Needs Pre-Action Governance
Models invent package names attackers can register. Registry checks catch most of them. They cannot tell an agent whether a real package is allowed here.
The Software Factory Is Finally Here. Its Decision Layer Is Missing.
Bob Bemer proposed the software factory in 1968. Coding agents finally supply the production capacity. Architectural control is the part still missing.
Behind the Scenes of My O'Reilly Radar Article
Why generated code can be locally correct and architecturally wrong, what makes a guardrail enforceable, and how to test one real boundary.
Anthropic’s AI-Native SDLC Playbook, Summarized and Extended
Anthropic's playbook puts advisory and deterministic controls in the agent loop. Architectural decisions need a policy layer that resolves which rule applies before each action.
Claude Code Self-Hosted Environments: Why Enterprise Agents Need Architectural Governance
Self-hosting controls where Claude Code executes. Architectural governance controls whether an authorized change still conforms to the decisions governing the repository.
How to Enforce Engineering Standards Across AI-Assisted Teams
AI multiplies code output but not architectural oversight. A four-layer model — decisions, standards, team context, verification — for enforcing engineering standards across human-agent teams.
Why Code Review Cannot Scale With AI Output
AI coding assistants generate code at 10–100× human pace. Code review is still linear. The math creates a bottleneck no team can hire its way out of — and why shifting enforcement left is the only real answer.
AI Code Review Does Not Scale Linearly
AI code generation scales nearly infinitely. Reviewer attention does not. The governance bottleneck this creates requires enforcement at generation time — not more reviewers or tighter PR processes.
Agent Pull Requests Are Everywhere: GitHub's Review Fix Targets the Wrong Layer
GitHub finds reviewers feel safer approving agent PRs that carry more technical debt, and prescribes a sharper review checklist. Detection at review time is the wrong layer for a governance failure created at generation time.
Mneme vs Cursor Rules
Cursor Rules are per-repo text files. Mneme HQ is a structured decision memory with a precedence engine and hook-level enforcement. The difference matters when your rules conflict or your team grows.
Cursor Developer Habits Report 2026: Why AI Coding Needs Governance Infrastructure
Cursor’s Developer Habits Report proves the velocity curve: more code, larger PRs, deeper agent sessions, and agent changes reaching commits without manual review (7% to 36.3%). The open problem is the governance curve.
Devin Reveals the Next Layer of AI Infrastructure: Architectural Governance
The industry solved generation velocity before architectural coordination. Autonomous software engineers make that gap visible.
Why CLAUDE.md Stops Scaling
Teams start with a small CLAUDE.md. Then the file grows into a governance system — with none of the infrastructure governance requires. Here is where the ceiling is and what comes next.
Claude Code Skills Validate a Bigger Shift: Organizational Knowledge Is Leaving the Prompt
Anthropic's own teams stopped packing knowledge into prompts and moved it into versioned, executable skills. Once knowledge becomes executable, the next question is governance: which skills are approved, and which decisions do they encode?
Architectural Governance Across Heterogeneous AI Coding Agents
Most orgs are no longer one-tool shops. Claude Code, Cursor, Copilot, Windsurf and bespoke SDK agents all touch the same codebase. Why per-tool memory cannot govern at the seams — and what does.
Goal-Driven Agents Need Architectural Governance
Claude’s /goal command, Karpathy’s AutoResearch, and Shopify’s metric-driven loops point to a shift from prompt-based coding to objective-driven development. Tests verify outcomes. Governance preserves architectural intent while the loop runs.
Agent Skills vs Architectural Governance
Agent skills teach agents how to perform tasks. Architectural governance constrains what agents are allowed to do to the system. These are complementary layers — and conflating them leaves system integrity unaddressed.
The Next Frontier Is Machine-Readable Pull Requests
Human-readable PRs explain. Machine-readable PRs allow verification. The future PR is dual-format.
PR Review Is Becoming an Incident Response Layer for AI Development
Under agentic development, the PR queue is quietly turning into the place organizations detect governance failures that should have been prevented upstream. Generation accelerates exponentially. Reviewer attention does not. That mismatch is governance collapse, not reviewer fatigue.
Why You Shouldn’t Treat AI Agents Like Employees: The Coding-Agent Corollary
A BCG and HBR experiment finds humanizing agents erodes accountability and degrades oversight. For coding agents, the replacement for employee-style trust is deterministic enforcement.
Why Agent-First IDEs Need Architectural Invariants
Delegated tasks need shared constraints. Invariants need to be encoded, retrieved, and enforced.
Using IBM Bob with Architectural Guardrails
IBM Bob accelerates enterprise delivery with agentic planning, subagents, and MCP. Architectural guardrails keep that speed inside your architecture.
AI Coding Agent Guardrails: Which Layers Actually Hold
A reference taxonomy of AI coding-agent guardrails: runtime, prompt, policy, architectural, and engineering-standards. What each layer catches, what it misses, and why architecture needs enforcement at edit time.
Smart Routing for AI Coding Agents: What Happens After You’ve Chosen the Right Model?
Smart routing decides which model handles a request. It optimizes execution, not architecture — every correctly routed agent can still bypass your ADRs. Here is the layer routing leaves out.
Loop Engineering for AI Coding Agents: Benefits and Limitations
Loops make coding agents persistent and self-correcting. They do not make them architecturally consistent: an agent can iterate twenty times and still violate the ADR it never questioned.
As AI Agents Gain Autonomy, Governance Moves Closer to Execution
The Bank of England is rethinking oversight for autonomous agents. Different domain, same principle: once systems act at machine speed, governance has to move in front of execution, not behind it.
Building Governance Layers for AI Coding Assistants
AI coding assistants are becoming agents that modify codebases, open PRs, and deploy. The missing enterprise infrastructure is a governance layer: policy, memory, enforcement, and auditability.
Loop Engineering Is Not New: The History of Loops as the Building Block of Software
The AI world talks about loop engineering as a new discipline. Loops have been computing's core abstraction for seventy years — what's new is a probabilistic generator inside the loop, which shifts the problem to governance.
Anthropic’s Zero Trust Stops at the Agent. Architectural Zero Trust Verifies the Diff.
Anthropic’s Zero Trust for AI Agents secures what an agent is allowed to do. But “never trust, always verify” doesn’t end at the agent’s identity — the diff it produces is the last untrusted packet, and a permission grant is not a conformance guarantee.
AI Peer Review Study: GPT-5.2 and Context Loss
GPT-5.2 outperformed top human reviewers on Nature-family papers — while still missing context already in the source. The governance lesson for enterprise AI.
Google Antigravity Solves Agent Coordination. It Does Not Solve Governance.
Antigravity makes agent work visible. The next layer has to make agent work governable.
OpenClaw and the Limits of Autonomous Coding
OpenClaw crossed 100,000 GitHub stars in its first week. Then it hit the wall every autonomous system hits eventually. What the rough week reveals about the engineering layer the industry hasn’t built yet.
What Is the AI SDLC? AI in the Software Development Lifecycle
The AI SDLC isn’t a new development methodology. It’s the familiar lifecycle — redefined by the speed, scale, and autonomy of AI-native code generation, and the governance gap that creates.
The Rise of Agentic Engineering Education
Universities, hackathons, and frontier labs are racing to launch agentic engineering programs. Almost none of them teach governance. The next AI engineering discipline has a curriculum gap that engineering organizations will pay for.