Add Friction to Tame AI Agent Coding Chaos
AI agents amplify code output 10x but breed addiction, massive PRs, brittle systems, and review overload. Fix with agent-legible modular codebases, linting enforcement, and deliberate human friction on critical changes like DB migrations.
Overcome Psychological Traps from AI Speed
AI tools hook engineers with addictive prompting—each iteration tempts 'just one more' to unlock features, mimicking gambling. This creates an illusion of efficiency: rapid output feels productive but skips design thinking, like questioning optimal implementations. Pressure mounts as baseline expectations shift—everyone must ship faster, turning early gains into unsustainable review piles. Teams imbalance: code production surges (engineers 10x output), but review capacity lags, pulling in non-engineers like marketers or ex-CEOs who ship without full responsibility. Result: skipped reviews, rubber-stamped PRs averaging 5,000 lines, eroding small-PR discipline.
After 12 months building agent systems, speakers note humans must reclaim agency—agents won't self-stop from irrelevant file reads or unchecked sprawl. Without intervention, amplification outpaces accountability, demanding recognition of this supply-review mismatch.
Fix Brittle Agent Code with Legible Architecture
Agents optimize for 'code that runs' via RLHF, producing novice-like patterns: config files defaulting silently (risking hours of bad DB writes), excessive local failure recovery, and progress-over-quality hacks humans intuitively avoid due to emotional checks. This builds entropy fast—codebases balloon to agent-incomprehensible complexity, duplicating logic or missing files.
Agents excel in libraries (tight APIs, simple cores) over products (intertwined UI/API/permissions/billing). Solution: treat codebases as agent infrastructure via 'agent-legible' design:
- Modularize ruthlessly: Isolate flows (e.g., user message → agent loop → output handling) to limit fuzz like unwanted state mutations or type parsing.
- Lean into RL patterns: Use React Server Actions or ORM over raw SQL to expose intent—no hidden magic.
- Lint-enforced mechanics: Ban bare catch-alls (agents self-fix violations), unify SQL in one query interface, single primitives UI library (no raw inputs), no dynamic imports, unique function names for token efficiency.
- Erasable TypeScript: JS with annotations—no transpiler confusion for error-finding.
Push complexity to abstraction layers; simple cores let agents grasp globals without context overflow, yielding reliable local changes.
Insert Friction to Leverage Human Judgment
Speed addicts, but devious on architecture/reliability—agents accrue months of tech debt in days. Counter with targeted friction:
- PR triage extensions: Auto-separate mechanical bugs (agent-auto-fixes) from human-callouts like DB migrations (assess locks/data size), permission changes (underdocumented risks), dependencies (vet maintainers).
- SLO-inspired gates: Intentionally slow critical paths—friction steers like tires on ice, forcing 'Do I need this reliability? Am I staffed?'
Net positives: Agents shine for bug reproduction (perfect starting points from customer reports) and product exploration (commit to reviewing generated code). Avoid for system design. Reassociate friction positively—it's where experience shines, preventing 'I committed broken prod code' regret. After 20 years (Flask creator), speakers urge: feel the pain agents ignore.