Agentic Coding

Briefing: Agentic Coding

Purpose: Practical guidance for software engineers building daily with AI coding agents — what's working, what's failing, tool comparisons, craft patterns, model selection, and lessons from building agent systems in production.

Key Insights

• The scarce skill is no longer writing code — it's managing the quality funnel agents create. AI agents don't eliminate bottlenecks; they move them downstream into code review, cognitive load, and organizational processes. Nicole Forsgren documents developers rebuilding mental models "dozens of times in a 30-minute period" from rapid agent feedback loops. Mike Krieger confirms teams "way overbuilt for V1" simply because they could. Mario Zechner provides the mechanism: agents making local decisions without system-wide awareness compound errors at rates humans never could. The practical implication is that your highest-leverage investment is in review infrastructure, task decomposition, and knowing when to intervene — not in maximizing token throughput.
• Nicole Forsgren: Leading high-performing engineering teams in the age of AI - The Pragmatic Summit
• Thoughts on slowing the fuck down

• Building Is the Easy Part Now | Mike Krieger on What AI Changed

• TDD with agents is the strongest consensus pattern, but you need a manual-test step to catch what suites miss. Simon Willison's workflow — write a failing test, let the agent implement, verify it passes, then start the server and curl the API — catches bugs that automated tests alone miss. Critically, agents follow existing codebase patterns "almost to a tea," so investing in project templates (Cookiecutter, strict linter configs, dev containers) pays more dividends than prompt engineering. Frequent git commits after every successful change provide rollback when agents go off the rails. The Facto evaluation framework confirms this: consistently, the environment (linter configs, build systems, dev containers) is the bottleneck, not the agent itself.

• Simon Willison: Engineering practices that make coding agents work - The Pragmatic Summit

• Nvidia Just Open-Sourced What OpenAI Wants You to Pay Consultants For.

• Agents fail 97.5% of real freelance projects, and 75% of frontier models break working features during maintenance — the fix is human-crafted evaluations, not better prompts. The gap between benchmark performance (where models approach expert-level with all context provided) and real-world completion rates is staggering. The "contextual stewardship" framework explains why: agents execute tasks better than ever but don't improve at maintaining long-term context. Senior engineers who hold the mental model of the system, understand decision history, and know unwritten operational details are becoming the scarce resource. Practically, this means writing evaluations that encode organizational context — like "before destroying any cloud resource, verify it is not tagged as production" — is the highest-value activity for senior practitioners.

• Your AI Agent Fails 97.5% of Real Work. The Fix Isn't Coding.

• The tool landscape has bifurcated into two workflow paradigms, and your choice should depend on task type, not brand loyalty. Claude Code/Opus models earn practitioner trust for high-stakes delegation work — Willison calls Opus 4.6 the point where he's "oneshotting basically everything." Karpathy notes Claude Code has better "personality" than Codex. Cursor's Composer 2, at 1/10th Opus cost, is compelling for fast in-the-loop iteration but is assessed as 6-8 months behind the frontier and "way worse" in design quality. The decision framework: use Claude Code terminal for delegation tasks where you walk away and review later; use Cursor/Composer 2 for tight, bounded cycles where you're actively steering. Chinese open-source models (Kimi K2.5 powering Composer 2 at 1/8th price) are closing the cost gap, but NIST found them 12x more susceptible to agent hijacking — a real security tradeoff for sensitive workloads.

• Mini-Vibe Check: Cursor Bets on Fast and Cheap With Composer 2
• Simon Willison: Engineering practices that make coding agents work - The Pragmatic Summit
• Cursor, Kimi & the Open Source Imperative

• The End of Coding: Andrej Karpathy on Agents, AutoResearch, and the Loopy Era of AI

• Stop treating "agents" as monolithic — a four-type taxonomy (coding harness, dark factory, auto research, orchestration) prevents expensive mismatches. Confusing types leads to failure: using auto research to build software or a coding harness to write a novel doesn't work. Coding harnesses replace individual contributors and depend on good task decomposition. Dark factories aim for spec-in, software-out with minimal human involvement in the middle. Auto research optimizes against quantifiable metrics (like CUDA kernel efficiency). Orchestration routes specialized tasks between agents but requires significant human oversight at handoff "joints." Cursor tried three levels of management in their multi-agent system and it failed, reinforcing that simplicity scales with agents.

• Tobi Lütke Made a 20-Year-Old Codebase 53% Faster Overnight. Here's How.

Emerging Patterns

• Context engineering is overtaking prompt engineering as the highest-leverage skill. Multiple independent practitioners converge on the finding that raw code generation capability is no longer the binding constraint. Karpathy describes customization relying on context windows rather than deep weight adjustments. Zechner diagnoses that agentic search has low recall in large codebases because agents only ever have a local view. The 97.5% failure study's most important finding is that the gap between capability and understanding is widening. Practically, maintaining agents.md files, expertise files, structured project knowledge, and evaluation systems that encode institutional context are the highest-ROI activities.
• The End of Coding: Andrej Karpathy on Agents, AutoResearch, and the Loopy Era of AI
• Thoughts on slowing the fuck down

• Your AI Agent Fails 97.5% of Real Work. The Fix Isn't Coding.

• The overnight coding loop pattern works, but only with persistent memory and deliberate evaluation infrastructure. The combination of memory, proactivity (/loop), and tool access transforms random experiments into intelligent search. Karpathy's Auto-Research runs ~100 experiments overnight on a single GPU with zero human intervention, converging on better training patterns through a persistent log. Anthropic's primitives replicate OpenClaw-like capabilities without the security nightmares of open network access and downloaded extensions. But without a "done signal" and human-crafted evaluations encoding what "success" means in your context, these loops burn tokens without converging.

• Anthropic Just Gave Your AI Agent the One Thing OpenClaw Has. Without the Risk.

• The End of Coding: Andrej Karpathy on Agents, AutoResearch, and the Loopy Era of AI

• Speed creates a review crisis that organizations haven't solved. Forsgren documents companies removing automated code review checks for AI-generated code due to concerns about verifiability — paradoxically shifting more burden back to humans precisely when volume is exploding. Krieger introduces "proof of thoughtfulness" as a new PR review standard: did the human reviewer actually understand and validate the model's decisions, or did they just verify tests pass? Multiple sources report designers now shipping 5-6 PRs per week and engineers running 4 concurrent agents — the organizational process layer hasn't adapted.

• Nicole Forsgren: Leading high-performing engineering teams in the age of AI - The Pragmatic Summit
• Building Is the Easy Part Now | Mike Krieger on What AI Changed
• Product-minded engineers in an AI-native world

Dissenting Views

• Full delegation vs. hands-on involvement remains a live debate with real consequences for code quality. Karpathy reports not having typed a line of code since December, framing all failures as "skill issues" in instruction and memory configuration rather than agent capability limits. Zechner presents the strongest counterpoint: companies claiming 100% AI-generated code "consistently put out the worst garbage you can imagine — memory leaks in the gigabytes, UI glitches, broken-ass features, crashes." His "compounding booboos" framework explains why: agents lack learning ability, make the same errors repeatedly, and without human bottlenecks, errors compound at unsustainable rates. Willison occupies a middle ground — with TDD, conformance suites, and review, agent code can be better than what he writes by hand because agents don't get lazy on refactoring. The resolution likely depends on codebase size, test infrastructure maturity, and task scope.
• The End of Coding: Andrej Karpathy on Agents, AutoResearch, and the Loopy Era of AI
• Thoughts on slowing the fuck down

• Simon Willison: Engineering practices that make coding agents work - The Pragmatic Summit

• Whether Cursor's in-the-loop IDE approach or Claude Code's delegation-first terminal approach is the right workflow depends on which bottleneck you're optimizing against. Cursor keeps the developer inside a visual workspace for real-time agent management, and Composer 2's speed compounds in tight cycles. Willison counters that Claude Code driving a terminal was the "killer moment" — he now codes on his phone via Claude Code for the web (sandboxed container) as his primary workflow, calling the ability to "oneshot" tasks with a two-sentence prompt the inflection point. The practical resolution: if your work is bounded, well-defined tasks where you're actively steering, Cursor wins on speed and cost. If you're delegating entire features or working across repos, terminal-based delegation with review is where the field is headed.

• Mini-Vibe Check: Cursor Bets on Fast and Cheap With Composer 2
• Simon Willison: Engineering practices that make coding agents work - The Pragmatic Summit

Read & Act

What to read:

• Simon Willison: Engineering practices that make coding agents work - The Pragmatic Summit — The single most actionable source in this collection. Specific patterns you can apply today: TDD loops for agents, conformance test suites, codebase templating with Cookiecutter, sandboxing strategies, and honest trust calibration across model generations (Opus 4.5 through 4.6). Willison's practitioner credibility is extremely high — he ships daily and describes exactly when he does and doesn't read agent-generated code.

• Thoughts on slowing the fuck down — The essential counterweight to agent hype. The "compounding booboos" framework, the explanation of why agentic search fails at scale (low recall in large codebases), and the concrete guidance on scoping agent tasks versus writing architecture by hand cannot be adequately summarized — the reasoning chain matters as much as the conclusions.

• Your AI Agent Fails 97.5% of Real Work. The Fix Isn't Coding. — Hard benchmark data (2.5% real-task completion, 75% maintenance regression) is essential context for anyone deploying agents in production. The "contextual stewardship" framework and the specific evaluation examples (check production tags before destruction, compare state files against manifests) are immediately applicable.

• Tobi Lütke Made a 20-Year-Old Codebase 53% Faster Overnight. Here's How. — The four-type agent taxonomy (coding harness, dark factory, auto research, orchestration) with clear decision criteria is a framework you'll use daily. The finding that Cursor tried three management levels and it failed, combined with the principle that "simple scales well with agents," provides architectural guidance that prevents expensive mistakes.

• Building Is the Easy Part Now | Mike Krieger on What AI Changed — Unique perspective from inside Anthropic Labs on agent-native product design. The "proof of thoughtfulness" concept for PR review, the tree-without-wind metaphor for products built too fast, and the practical finding that half your product needs rethinking every 3-6 months are insights from someone shipping these systems at scale.

What to do:

• Audit your codebase environment before optimizing your prompts. Facto's evaluation framework consistently shows that linter configs, build systems, and dev containers are the actual bottleneck for agent performance — not the agent's logic. This week, tighten your linting rules to enforce extremely clean code, ensure your project has comprehensive templates (Cookiecutter or equivalent) that encode your conventions, and verify your dev containers work cleanly. Agents follow existing patterns almost perfectly; give them better patterns to follow.

• Write three contextual evaluations for your most critical production systems. Not "did the code compile" checks — evaluations that encode organizational knowledge. Examples: "Before modifying any infrastructure resource, verify it is not tagged as production." "Before any database migration, compare the current schema against the known production manifest." These are the checks senior engineers intuitively perform. Making them machine-readable is the highest-leverage activity for preventing agent-driven incidents.

• Adopt the commit-per-change workflow and classify your agent tasks by type. Git commit after every successful agent change — this sounds excessive but provides instant rollback when agents go off the rails. Separately, categorize your current agent work using the four-type taxonomy: is this a coding harness task (optimize what's in front of you), a dark factory task (spec-in, software-out), auto research (optimize a metric), or orchestration (route workflows)? Using the wrong type for the wrong job is the most common source of agent system failures practitioners report.