Agentic Coding

Briefing: Agentic Coding

Purpose: Practitioner-layer intelligence for software engineers building with AI coding agents daily — what's working, what's failing, and what to do about it.

Key Insights

• The agent harness — not the model — is where the real engineering leverage lives. The Claude Code leak revealed a three-tiered memory system (pointer index, sharded topical information loaded on relevance, self-healing search against environment state) alongside strict write discipline that only records to memory when actions are verified against the actual environment. A single JetBrains developer built a custom harness using ACP + Deep Agents that replaced Claude Code as their daily driver, proving the harness layer is reproducible software, not magic. The practical implication: treat model choice as a swappable component and invest your engineering effort in memory management, tool orchestration, and session persistence.
• Post-Mortem of Anthropic's Claude Code Leak
• Using ACP + Deep Agents to Demystify Modern Software Engineering

• Deep Agents Deploy: an open alternative to Claude Managed Agents

• Unattended agents fail in specific, documented ways — and your codebase quality is the primary variable that determines agent output quality. Vercel's Turborepo optimization project found that unattended agents never benchmarked their own work, hyperfixated on initial ideas, chased meaningless microbenchmarks, and never wrote regression tests. Critically, agents spontaneously started writing tests and creating better abstractions once merged human-reviewed code demonstrated those patterns — the source code itself became the feedback loop. The "State of Agentic Coding" hosts independently confirmed that agents produce excellent work on well-abstracted infrastructure but create messes in complex product code with intertwined feature flags, and that only 5 out of 600 PRs in one agent-driven project contained the word "refactor."

• Making Turborepo 96% faster with agents, sandboxes, and humans

• State of Agentic Coding #5 with Armin and Ben

• If it's hard for you to read, it's hard for the agent — and context format changes can produce order-of-magnitude improvements. Switching Turborepo profiling output from Chrome Trace JSON to Markdown-formatted data produced "radically better optimization suggestions" from the same model, same codebase, same harness. TanStack's "code mode" replaced multiple LLM tool calls with a single generated-and-executed TypeScript program, cutting context from 9.8KB to 1.7KB and latency from 27s to 8s; adding a skills cache further reduced context to 0.5KB and time to 3s. Even the crude "Caveman" technique of stripping articles and pleasantries from prompts achieved an 87% token reduction on explanations, with research showing brevity constraints improve accuracy by 26 percentage points.

• Making Turborepo 96% faster with agents, sandboxes, and humans
• Introducing TanStack AI Code Mode

• No way this actually works

• Senior developers are the primary beneficiaries right now, and "green CI" is no longer proof of safety. DHH reports processing 100 PRs in 90 minutes with agent-assisted review, with Claude identifying issues he was unaware of, delivering 5-10x productivity for senior developers who can critically assess output. Vercel's engineering team warns that passing CI merely reflects "the agent's ability to persuade your pipeline that a change is safe" and advocates runtime validation, read-only audit agents, and defect-commit vs. defect-escape ratios. Amazon's internal analysis reportedly concluded that junior programmers cannot reliably ship agent-generated code to production without senior review.

• DHH's new way of writing code

• Agent responsibly

• If you're building products that agents will use, meet them at their best semantic layer — not your existing API surface. PostHog's v1 mistake was wrapping every API endpoint as an MCP tool; v2 collapsed all read/get endpoints into a single SQL interface because LLMs already reason fluently in SQL. Their playbook: front-load universal context (taxonomy, syntax, hard constraints) every session, write skills as guidance for qualified individuals not step-by-step manuals, and dogfood headlessly via CLI before testing in UI. Weekly trace reviews of real user sessions with feedback ratings close the loop.

• The golden rules of agent-first product engineering

Emerging Patterns

• Terminal-first development is accelerating, but the IDE isn't dead — it's narrowing to code review. DHH uses OpenCode as his primary harness, the "State of Agentic Coding" hosts observe declining IDE usage with Cursor 3 moving away from traditional IDE paradigms, and Scott Chacon at GitButler is designing Git output formats specifically for terminal-based agents (--json, --markdown, --status-after). The remaining IDE value is concentrating in diff review and context visualization — hence one practitioner built "Hunk," a custom diff tool, and predicts a surge of similar tools. The JetBrains/ACP author pushes back, arguing that IDE integration provides superior context visualization and a cohesive experience for manual editing, suggesting the practical answer is terminal for agent interaction and IDE for review.
• DHH's new way of writing code
• State of Agentic Coding #5 with Armin and Ben
• Rethinking Git for the Age of Coding Agents with GitHub Cofounder Scott Chacon

• Using ACP + Deep Agents to Demystify Modern Software Engineering

• Agents have specific, catalogued anti-patterns that compound into unmanageable codebases if unchecked. LLMs over-use try-catch to avoid crashing, generating unnecessary complexity when a hard failure would be appropriate. They don't reuse existing code — they generate redundant implementations because writing is cheaper for them than searching, producing "drift" across monorepos. They won't tell you the codebase is becoming unmanageable, they provide no backpressure, and they'll confidently argue for any position including wrong ones for up to an hour before you realize your original intuition was correct. AI is also notably poor at CSS — solving problems locally with bloated one-off classes, ignoring modern features like nesting, and producing designs that look identical across projects.

• State of Agentic Coding #5 with Armin and Ben
• 994: AI Sucks At CSS
• Agent responsibly

Dissenting Views

• Can future models fix current code slop? Sources directly contradict each other (difference in emphasis). The "State of Agentic Coding" hosts express "very low trust that you can outslop yourself with future models" — if the codebase was already too messy for Claude 3.5 last May, a state-of-the-art model today won't make it perfect, and rebuilding may be the only path. The Turborepo team observed the opposite dynamic: as human-reviewed improvements were merged into the source, agents spontaneously stopped reproducing old patterns and started writing tests without being asked, suggesting the codebase itself teaches the agent. The reconciliation matters for your workflow: the source code is a feedback mechanism, but it only works if you're actively investing in quality through human review — passive accumulation of agent slop creates a debt that compounds, not one that self-corrects.
• State of Agentic Coding #5 with Armin and Ben

• Making Turborepo 96% faster with agents, sandboxes, and humans

• Working with agents is exhilarating vs. working with agents is psychologically unhealthy (direct contradiction). DHH describes the experience as "enjoying my time as a programmer more than any time since early 2000s" and likens it to stepping into a "super mech suit." The "State of Agentic Coding" hosts counter that "the experience of using an agent is basically being on drugs," that late-night agent interactions "don't look healthy," that agents provide zero backpressure (they'll compliment your ingenuity as the context window collapses), and that people are developing relationships with their agents that border on problematic. Both perspectives appear to be genuinely reported experiences, suggesting the same tool can create either dynamic depending on how you manage your relationship with it.

• DHH's new way of writing code
• State of Agentic Coding #5 with Armin and Ben

Read & Act

What to read:

• Making Turborepo 96% faster with agents, sandboxes, and humans — The single best practitioner case study in this set. The specific workflow (profile → review → implement → benchmark → PR), the discovery that Markdown-formatted profiling data produced radically better agent suggestions than JSON, and the honest catalog of every way unattended agents failed are all patterns you can apply to your next performance or refactoring project.

• State of Agentic Coding #5 with Armin and Ben — The sharpest practitioner-layer conversation available. Will challenge your assumptions about shipping speed: the "drift" problem in monorepos, the try-catch anti-pattern, the refactor-PR health metric (count PRs with "refactor" in the title — 5 out of 600 is a red flag), and the honest psychological toll of late-night agent sessions. Worth the full listen despite the length.

• Post-Mortem of Anthropic's Claude Code Leak — If you're building custom agent systems, the architectural patterns revealed here are directly actionable: pointer-based memory indexes, sharded topical information loaded on relevance, strict write discipline that only records verified outcomes, and auto-dream consolidation for long-running sessions. The key reframe: the harness is the IP, not the model.

• Rethinking Git for the Age of Coding Agents with GitHub Cofounder Scott Chacon — Addresses a blindspot most practitioners haven't considered yet: Git's interface wasn't designed for machine users, agent metadata (thinking logs, tool calls, transcripts) is a ballooning data problem, and GitButler's parallel branches feature enables multiple agents working the same directory without merge conflicts. Read this before your multi-agent usage scales.

• The golden rules of agent-first product engineering — PostHog's playbook for building products agents will use. The v1-to-v2 evolution (wrapping every endpoint vs. exposing SQL) is a lesson you can apply immediately if you're designing any agent-facing API surface.

What to do:

• Audit your codebase's agent-readiness before scaling agent usage. Count the PRs with "refactor" in the title over the last month. If the ratio is near zero, your codebase is accumulating agent drift. Invest in a focused refactoring sprint on the highest-entropy areas before letting agents generate more code there. The Turborepo team demonstrated that agent output quality improves automatically once the merged codebase demonstrates good patterns.

• Convert one key data format your agents consume from raw/JSON to human-readable Markdown and measure the difference. The Turborepo case showed that identical models with identical harnesses produced "radically better" suggestions with better-formatted input. Try this with profiling data, error logs, or API responses your agents regularly process. If the data is hard for you to scan at a glance, the agent is struggling with it too.

• Implement a "plan → human review → implement → deterministic validate → ship" loop as your default agent workflow. Stop letting agents run unattended to completion. Start every task in plan mode, review the plan, let the agent implement, then validate with deterministic checks (benchmarks, tests, linting) before merging. Track your defect-commit vs. defect-escape ratio as Vercel recommends — this single metric will tell you whether your oversight loop is working.