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. Browse all insights.
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.