Agentic Coding

Briefing: Agentic Coding

Key Insights

• Your evaluation harness matters more than your model choice — by a 22-point margin. Google DeepMind's large-scale benchmark analysis found that the evaluation harness alone accounts for a 22% performance swing, while frontier models cluster within 2-3% of each other on SWE-Bench Pro. This means the hours you spend debating Claude Opus vs. GPT-5.5 are likely less valuable than the hours you could spend instrumenting your agent environment. Cursor's CursorBench methodology was explicitly designed to separate models on realistic tasks that SWE-bench fails to differentiate — and Composer 2.5 achieves 63% on it at roughly 1/20th the cost of Opus 4.7.
• Agentic Evaluations at Scale, For Everybody — Nicholas Kang & Michael Aaron, Google DeepMind
• Cursor just crushed Claude Code

• Training Composer 2

• The human reviewer is the serial bottleneck, not the model — and Amdahl's Law proves it's a hard ceiling. Addy Osmani's framing is precise: you are the GIL of your agent fleet. Every task requiring architectural judgment, merge conflict resolution, or genuine code understanding must acquire the single "human lock," and spawning more agents deepens the queue without expanding the lock. The practical counter-pattern is to design workflows that reduce what requires human review: make agents write passing tests as proof-of-work, use automated pre-commit hooks, run overnight deep reviews, and push more work into "dark factory" autonomous execution. At Dropbox, the explicit design principle was "not every step belongs inside the agent loop" — deterministic CI stays outside, agents re-enter only on failure.

• The Orchestration Tax is You
• Introducing Nova, our internal platform for coding agents

• How the Fastest Teams Actually Ship Code with AI

• Multi-model review is now a concrete pattern, not a vague suggestion — and three independent teams arrived at it. The productmarketfit.tech workflow, Nolan Lawson's personal practice, and OpenAI's internal infrastructure recommendation all converge on the same architecture: generation model → parallel review agents using different models with context cleared between sweeps → human approval gate. The specific "don't let the same model sign off on its own code" principle prevents identical blind spots from propagating. Lawson's implementation (Claude sub-agent + Codex + Cursor Bugbot in parallel) reports near-zero false positives and uncovers pre-existing bugs that the original generation session missed.

• How the Fastest Teams Actually Ship Code with AI
• Using AI to write better code more slowly

• The Infrastructure Nightmare Nobody Is Talking About

• Context management is now a first-class engineering discipline, not an afterthought. The 120K "dumb zone" is empirically estimated as the threshold where attention degrades and agents start making worse decisions. The state-of-the-art practice separates context into at least two tiers: claw.md / AGENTS.md for prescriptive rules (things the model should always do), and memory.mmd for dynamic facts that change — and these should never be mixed. The 300-line ceiling with "compress-not-raise" enforcement, the handoff-to-markdown pattern for crossing session boundaries, and cascading project-level memory files (root → project → workstation) are all currently deployed patterns that reduce token costs by measurable amounts (one practitioner reports 25% reduction from cutting claw.md from 600 to 250 lines).

• 9 Things People Get Wrong With My /grill-* skills
• /handoff is my new favourite skill

• Top 5 Claude Cowork Tips I Wish I Knew from Day One

• The cost/quality frontier shifted materially this cycle — but token efficiency is the hidden variable most comparisons miss. Composer 2.5 achieves near-parity with GPT-5.5 on CursorBench (63% vs. 64%) at roughly 20x lower cost. But Gemini 3.5 Flash's story illustrates the trap: despite strong Terminal-Bench scores, it consumed 200M output tokens on the same benchmark where GPT-5.5 Medium used 22M. Per-token price is misleading if the model generates 9x more tokens to accomplish the same task. DeepSeek's permanent 75% discount positions it at roughly 1/19th the cost of Opus 4.7 on intelligence-adjusted benchmarks, reshaping the open-source cost floor. The practical implication: measure tokens-to-completion on your actual tasks, not just per-million pricing.

• Cursor just crushed Claude Code
• [AINews] All Model Labs are now Agent Labs
• [AINews] Google I/O 2026: Gemini 3.5 Flash, Omni (NanoBanana for Video), Spark (background agents), and Antigravity 2.0

Emerging Patterns

1. AI-generated issues and PRs are poisoning agent context at scale. The OSS maintainer perspective reveals a failure mode invisible from inside a team: AI-generated GitHub issues contain plausible-but-wrong diagnoses that contaminate subsequent agent context even when you explicitly instruct the agent not to trust them. The Ariel Rossano Pi project reports a <10% PR merge rate on 3,145 external submissions over 90 days, with most auto-closed. More importantly, the cheapness of local workarounds means agents build defensive code around symptoms rather than communicating fixes upstream — fragmenting effort and degrading system invariants over time. If you're building on top of OSS dependencies or accepting external contributions, this is an active input-contamination problem for your agents. - Building Pi With Pi - Skill issue: Lessons from skilling up coding agents to use Langfuse - Marc Klingen, Clickhouse

2. The harness-model symbiosis is being co-trained, not bolted on. Cursor's Composer 2.5 was explicitly trained with the Cursor harness — not on top of it. The 22% harness effect from DeepMind's evaluation research, combined with Cursor's own claim that their harness+model combination outperforms standalone frontier models on their benchmark, suggests that harness and model are increasingly a single deployable unit rather than separable components. The implication for practitioners building agent systems: optimizing your harness and prompts is now a more leveraged activity than model-hopping, and the harnesses trained by Cursor/Anthropic/OpenAI for their own tools give them an inference subsidy that raw API users don't get. The model-eats-the-scaffolding pattern (Google DeepMind's framing) predicts that what's currently harness engineering will increasingly be absorbed into the model itself — but that transition is not complete. - Training Composer 2 - Agentic Evaluations at Scale, For Everybody — Nicholas Kang & Michael Aaron, Google DeepMind - The Model Eats the Scaffolding: DeepMind's Logan Kilpatrick & Tulsee Doshi on 3.5 Flash, Omni & More

3. Faster inference changes the viable workflow surface, not just the speed of existing workflows. Cerebras's Codex Spark at 1,200 tokens/second is not just a faster version of the "spawn-and-go-get-a-hamburger" pattern — it makes a qualitatively different set of workflows viable. Context compaction that previously took 10 minutes now completes in 30 seconds, making sloppy context hygiene visible in real time. Validation loops (tests, linting, diff review) become effectively free, meaning there's no longer an acceptable reason to skip them. And the generation-of-15-versions-to-cherrypick pattern becomes practical where it was previously token-prohibitive. The practitioner implication: if you're still using the same workflow you used with slower models, you're leaving a qualitative workflow shift on the table. - Fast Models Need Slow Developers — Sarah Chieng, Cerebras - The Model Eats the Scaffolding: DeepMind's Logan Kilpatrick & Tulsee Doshi on 3.5 Flash, Omni & More

Dissenting Views

On whether you should slow down and review, or let agents run fast — this is a genuine methodological split, not a semantic one. The prevailing view among productivity-maximizers is that automated validation (tests, CI, pre-commit hooks) should replace manual code review for most agent output, with humans in the loop only at architectural decision points. Nolan Lawson's direct counter-evidence: his multi-agent review process systematically surfaces pre-existing bugs that the original session never touched, suggesting that treating agent output as a first draft worthy of serious scrutiny produces higher-quality codebases even if it reduces raw velocity. The OpenAI infrastructure team's position is a third option: build agentic code review harnesses that automate the human review work itself, rather than either accepting agent output or manually reviewing it. The right answer likely depends on codebase criticality and blast radius — but the Lawson data is worth taking seriously before assuming automated validation is sufficient. - Using AI to write better code more slowly - The Infrastructure Nightmare Nobody Is Talking About - Fast Models Need Slow Developers — Sarah Chieng, Cerebras

On AGENTS.md files: foundational practice or prompt technical debt? The mainstream advice is to maintain a comprehensive AGENTS.md with repo layout, commands, conventions, and "do not do" rules — and multiple teams report it's prerequisite to getting useful output. The direct counter-argument: prompts are technical debt that decays silently with model upgrades, unlike code which at least throws visible errors when it breaks. Using /init to auto-generate your agent MD files is specifically called out as making models dumber by filling context with AI-generated filler that sounds plausible but degrades performance. The operational resolution: write agent MD files by hand, include only concrete specific facts (not behavioral steering or motivational phrases), keep them under 300 lines, and treat them as technical debt that needs active maintenance after every major model upgrade. - How the Fastest Teams Actually Ship Code with AI - Github pwn'd, Karpathy + Anthropic, Cursor drops Composer 2.5, Codex App goes mobile... - Don't Build Slop (4 Levels of AI Agent Maturity) - Ara Khan, Cline

Read & Act

What to read

• How the Fastest Teams Actually Ship Code with AI — The most complete operational blueprint available: AGENTS.md structure, plan-before-prompt workflow, multi-model review (generation vs. review model separation), CLI pre-commit review, PR review, and overnight deep codebase analysis. Every component is specific enough to implement today. Read this before spending another hour debating which model to use.

• Introducing Nova, our internal platform for coding agents — Rare honest engineering documentation from a company that shipped: isolated snapshot environments, validate-and-continue loops for flaky test remediation (100+ CI runs), and the specific design decision that deterministic CI should stay outside the agent loop. Read this if you're building agent infrastructure rather than just using it.

• Dispatches from O'Reilly: The accidental orchestrator — The most credible practitioner account of building a real production system with AI agents: the C compiler experiment ($20K, 16 Claude instances, still needed human intervention at scale), the "AI is biased toward adding code, not deleting it" anti-pattern, and context file practices that transferred cleanly between Claude Code and Cursor. Read this for the failure modes you won't find in documentation.

• Agentic Evaluations at Scale, For Everybody — Nicholas Kang & Michael Aaron, Google DeepMind — Read specifically for the 22% harness effect data point. If the harness accounts for more performance variance than the model selection decision you've been agonizing over, this single finding should reorder your priorities. Thirty minutes of watching time that may save you weeks of model-switching experiments.

• Training Composer 2 — Essential for understanding why CursorBench separates models that SWE-bench can't, how self-summarization handles infinite-length tasks, and why Gemini's end-result RL produces malformed tool calls while Cursor's targeted textual feedback approach doesn't. Read this if you want to understand the model-harness co-training dynamic that will increasingly define which tools outperform on your actual tasks.

What to do

• Run a context audit on your current AGENTS.md or CLAUDE.md this week. Open your agent configuration file and count lines. If it's over 300 lines or was generated by /init, it's actively consuming tokens and likely degrading performance. Apply the two-test filter to every entry: if it contains "always" or "never" it belongs in the rules file; if it's a fact that could change it belongs in memory. Delete everything else. Track your token usage before and after — one practitioner measured a 25% reduction from this exercise alone.
• Top 5 Claude Cowork Tips I Wish I Knew from Day One

• Github pwn'd, Karpathy + Anthropic, Cursor drops Composer 2.5, Codex App goes mobile...

• On your next non-trivial PR, run the three-model parallel review before merging. Set up Claude, Codex, and at least one other model to review the same diff concurrently, with context cleared between each. Compile their findings, verify against false positives, and categorize by severity. Compare what this surfaces against your normal review process. This is a one-time experiment that will calibrate whether the multi-model review pattern is worth systematizing for your codebase — and Nolan Lawson's reported finding is that it uncovers pre-existing bugs, which means you're learning about your codebase's failure modes regardless of whether you adopt the full workflow.

• Using AI to write better code more slowly

• How the Fastest Teams Actually Ship Code with AI

• Before your next model switch, measure tokens-to-completion on a representative set of your actual tasks. Pick 5-10 representative tasks from your last sprint, run them against your current model and one alternative, and record both output quality and total output tokens consumed. The Gemini 3.5 Flash example (200M tokens for the same benchmark where GPT-5.5 used 22M) shows that per-token pricing is a misleading proxy. Building even a rough measurement of tokens-per-completed-task will give you better cost/quality data than any published benchmark, because it will be measured in your specific harness on your actual work.

• Cursor just crushed Claude Code
• Agentic Evaluations at Scale, For Everybody — Nicholas Kang & Michael Aaron, Google DeepMind