Agentic Coding

COMPLETED April 20, 2026
Summary

Briefing: Agentic Coding Purpose: Practitioner-focused synthesis for software engineers building with AI coding agents daily.

Key Insights

  • Your harness matters more than your model. On Terminal-Bench 2.0, the same Claude Opus 4.6 scores dramatically lower inside Claude Code's default harness than inside a custom one — and one team jumped from Top 30 to Top 5 by changing only the harness. The top coding agents (Claude Code, Cursor, Codex, Aider) are converging on the same harness patterns even though their underlying models differ, which means your next productivity gain is more likely to come from adding a hook that blocks destructive commands, writing a better AGENTS.md, or implementing progressive tool disclosure than from switching models. Treat every agent mistake as a permanent signal: each rule in your AGENTS.md should trace to a specific past failure, kept under 60 lines like a pilot's checklist.
  • Agent Harness Engineering
  • Building pi in a World of Slop — Mario Zechner

  • Harness Engineering: How to Build Software When Humans Steer, Agents Execute — Ryan Lopopolo, OpenAI

  • Opus 4.7 is a sharper tool that requires a sharper operator — update your rails or regress. Anthropic confirmed that 4.6 was doing "prompt engineering on your behalf" that 4.7 deliberately does not, meaning it follows your instructions literally and will stall or guess wrong on vague prompts. Expect old prompts to break. Rewrite them with explicit acceptance criteria, constraints, and effort-level specifications. The ~40% effective cost increase from the new tokenizer (1.46x more tokens for text, 3.01x for images) compounds this: you're paying more per task AND need to specify more. For long-horizon async tasks, say "I'm going to bed" — the Anthropic researcher confirmed this gives the model license to use more tokens and iterate longer. Use effort levels strategically: max for benchmarks, extra-high (the new default) for async handoffs, high/medium for interactive work.

  • Vibe Check: Opus 4.7 Stopped Reading Between the Lines
  • LIVE VIBE CHECK: OPUS 4.7 DROPS
  • Claude Token Counter, now with model comparisons

  • The Price of Precision

  • Scaling agentic coding in production requires organizational infrastructure, not just better models. Intercom doubled merged PRs per R&D employee in nine months with Claude Code, but they already had mature CI/CD, comprehensive test coverage, and a high-trust culture. Cloudflare hit 93% R&D adoption across 3,683 users by routing all LLM requests through AI Gateway, auto-generating AGENTS.md files from their Backstage service catalog, building an Engineering Codex that agents reference during review, and achieving 100% AI code review coverage. The anti-pattern is deploying agents into organizations with broken pipelines — AI will just help you ship broken code faster. Leadership's critical role: Intercom's framework is "tell people they can do things, and if anything goes wrong, blame me."

  • 🎙️ This week on How I AI: How Intercom 2x'd their engineering velocity with Claude Code

  • The AI engineering stack we built internally — on the platform we ship

  • The Karpathy loop — edit/run/measure/keep-or-discard applied to harness engineering itself — is the emerging paradigm for auto-optimizing agent systems. An agent ran 12 experiments per hour overnight, yielding an 11% speedup from ~20 genuine improvements. Shopify's CEO got a 19% performance gain from 37 experiments in 8 hours. When this loop was applied to the harness itself (meta-agent optimizing system prompts, tool definitions, routing logic), the meta-agent independently invented spot-checking, verification loops, progressive disclosure, and task-specific sub-agents. Critical constraint: same-model pairings (Claude meta-agent for Claude task-agent) dramatically outperform cross-model pairings. The critical guardrail: agents overfit to proxy metrics. Your eval infrastructure — not your model — is the bottleneck.

  • Karpathy's Agent Ran 700 Experiments While He Slept. It's Coming For You.

  • Agentic compute costs are fracturing in three directions simultaneously, and you need a routing strategy. Cloud frontier models are getting more expensive per-task (Opus 4.7's tokenizer, Copilot tightening limits because "a handful of requests now exceed the plan price"). Smarter models use fewer total tasks (Opus 4.5 used 76% fewer tokens than Sonnet for the same outcome). Meanwhile, local models on Apple silicon (MLX variants, 2x faster than GGUF) are viable for sub-16K-context "micro agent tasks" — but 30-second latency at 16K context kills usability. Open models like Kimi K2.6 (Terminal-Bench 66.7%, SWE-Bench Pro 58.6%) are becoming competitive with closed frontier models. Route simple tasks to cheap/fast models, reserve frontier models for planning and complex reasoning, and monitor actual token consumption.

  • Changes to GitHub Copilot Individual plans
  • My M5 Max, Gemma 4, MLX LOCAL Stack. (This KILLS MODEL PROVIDERS)
  • Kimi K2.6: Advancing open-source coding
  • The Price of Precision

Emerging Patterns

Dissenting Views

  • How much should you read agent-generated code? Practitioners are split on a spectrum from "never look at it" to "write it by hand if it matters." One developer building an MMO RPG says "I reached a point where I just stopped reading the code — I just prompt, commit, and push." An investor argues "I don't ever have to look at code again — the next model will rewrite any bad functions." But Mario Zechner (Building pi in a World of Slop) counters: "If you do anything important, write it by hand... that friction builds understanding." A podcast host insists: "I purposefully and intentionally refactor the code myself — you cannot trust that the agent knew what it's doing." This isn't semantic disagreement — it reflects genuinely different risk tolerances. For side projects and prototypes, skipping review is a viable time-optimization. For production systems, the consensus among experienced practitioners leans heavily toward human review, with AI-assisted review (Code Rabbit, Bugbot, Claude reviewer) as a scaling mechanism rather than a replacement.
  • Building pi in a World of Slop — Mario Zechner
  • Bun.WebView, Cursor's Big Bet, and Whether Mythos Just Spells Marketing | News | Ep 63

  • Network Effects, AI Costs, and the Future of Consumer Investing with Anish Acharya on The Kevin Rose Show

  • Plan mode: valuable discipline or classic over-engineering? This is a difference in emphasis, not a binary. One practitioner says "having a good plan up front is very valuable in the long run of agent coding." Another counters: "I think people over-review their plans and I think this is a classic mistake." An OpenAI engineer doesn't use plan mode at all — "I should be able to drop a ticket in and have it do the job anyway." The resolution likely depends on task complexity: plan mode pays off for complex features with many edge cases where the agent will ask clarifying questions, but adds friction for straightforward changes where reprompting is faster than reviewing a plan. Use plan mode when you're uncertain about requirements; skip it when you know exactly what you want.

  • Why you shouldn't vibe code without tests
  • LIVE: Watch me build a brand-new project from scratch
  • Harness Engineering: How to Build Software When Humans Steer, Agents Execute — Ryan Lopopolo, OpenAI

Read & Act

What to read:

  • Agent Harness Engineering — The single most actionable reference in this batch. Covers compaction, hooks, progressive disclosure, context resets, planning patterns, and autonomous coding loops — each grounded in Terminal-Bench data. Use it as a checklist against your current setup this week.

  • The AI engineering stack we built internally — on the platform we ship — The best available case study of agentic coding at organizational scale. Details on auto-generating AGENTS.md from Backstage metadata, the Engineering Codex as progressive-disclosure agent skills, Code Mode for reducing MCP tool token overhead, and the 91%/9% frontier/local model split provide a blueprint for team-wide rollout.

  • Vibe Check: Opus 4.7 Stopped Reading Between the Lines — Essential if you use Claude models daily. Multi-tester analysis surfaces the behavioral shift with specificity no changelog matches: the P&L error detection regression, effort-level recommendations, and honest disagreement between testers about when to fall back to 4.6.

  • Karpathy's Agent Ran 700 Experiments While He Slept. It's Coming For You. — Introduces the auto-optimizing harness paradigm with enough specificity to implement: the Karpathy triplet (one editable surface, one metric, one time budget), meta/task agent split, same-model pairing requirement, and the critical warning about metric gaming. Read this if you're building agent products, not just using them.

  • Building pi in a World of Slop — Mario Zechner — The strongest contrarian voice. His critique of Claude Code's context control, discovery of Open Code's tool output pruning bugs, and the Terminal-Bench finding that a minimal keystroke-only harness outperforms richer setups challenge multiple consensus positions. If you're choosing between tools or building a harness, this provides the skepticism needed to avoid lock-in.

What to do:

  • Audit your AGENTS.md files (or create them) against the Addy Osmani checklist this week. Every rule should trace to a specific past failure. Keep it under 60 lines. Add a hook that blocks your most common destructive command (e.g., rm -rf, force-push to main). If you're at an org with a service catalog like Backstage, explore auto-generating AGENTS.md from catalog metadata like Cloudflare does — this scales context provision across hundreds of repos without manual effort.

  • If you're on Opus 4.7, rewrite your three most-used prompts with explicit acceptance criteria, constraints, and effort-level specifications. Test with effort level set to "extra high" for async tasks and "high" for interactive work. Compare output quality and token consumption against your 4.6 baseline. If you relied on 4.6 catching errors you didn't ask for (like the P&L example), add explicit verification steps to your prompts — that proactive behavior is gone.

  • Pick one measurable system in your codebase and define the Karpathy triplet: one editable surface the agent can modify, one metric to optimize, and one time budget per experiment. Run it overnight. Even if you don't implement the full auto-optimization loop, the exercise of defining what "good" looks like as a scoreable metric will improve your eval infrastructure — which multiple sources identify as the true bottleneck for scaling agentic coding.

Source Articles

← More from Agentic Coding