Agentic Coding

Briefing: Agentic Coding

Key Insights

• "Vibe Coding" is dead; upfront architecture is the new bottleneck. Relying on agents to design systems from scratch inevitably leads to "slop creep"—the gradual, invisible accumulation of poor architectural decisions. To prevent this, practitioners are shifting 70% of their effort to the planning phase, demanding explicit code snippets for key data models and interfaces before allowing the agent to write implementation code. The human engineer's role has fundamentally shifted from typing to system design and rigorous constraint setting.
• Slop Creep: The Great Enshittification of Software
• Compound Engineering Camp: Every Step, From Scratch

• The Never-done Machine

• AI velocity creates catastrophic "comprehension debt." Agents can now generate code significantly faster than a senior engineer can critically audit it, entirely breaking traditional pull request workflows. While test suites may remain green, they mask a growing gap between the size of the codebase and the amount of it any human actually understands. Teams that optimize purely for merge velocity without treating genuine human comprehension as a non-negotiable metric will face painful future reckonings when incidents occur.

• Comprehension Debt — the hidden cost of AI generated code.

• Slop Creep: The Great Enshittification of Software

• Token bloat and context rot are killing agent reliability. Treating context windows as infinite garbage dumps guarantees degraded AI performance and developer exhaustion. Elite practitioners actively manage context through mechanical techniques: using YAML headers on "skill files" so the AI can scan metadata before reading full documents, utilizing tree commands to gather fresh repository state, and leaning heavily on explicit session branching/rewinding to keep prompts hyper-focused.

• How to Automate ANYTHING with Claude Code (as a normal person)
• Pi Day: AMA with Pi's Creator + Talks & Extensions Deep Dive

• LLMs can be exhausting

• Strategic model routing beats single-model reliance. There is no longer a single best model for coding; mastery requires pipeline orchestration based on behavioral profiles. Developers are pairing Claude Opus for meticulous planning, Sonnet 3.5 or Haiku for cheap worker execution, and Gemini 2.5/CLI for instantaneous, 90-second PR reviews across massive context windows. Additionally, for fast tool execution, lightweight in-process interpreters are heavily outperforming complex sandboxes like Pyodide by reducing latency to microseconds.

• ⚡️Monty: the ultrafast Python interpreter by Agents for Agents — Samuel Colvin, Pydantic
• Compound Engineering Camp: Every Step, From Scratch

Emerging Patterns

• Eval-driven development loops replace human-in-the-loop generation. Rather than interrupting and manually steering an agent mid-generation—which wastes tokens and degrades output—developers are adopting TDD-style workflows for agents. By providing a strict sub-5-minute failure case reproduction target, engineers force the agent to work autonomously until programmatic evaluations pass, drastically reducing debugging time and mental fatigue.
• LLMs can be exhausting

• AI Made Every Company 10x More Productive. The Ones Cutting Headcount Are Telling on Themselves.

• Terminal environments beat heavy IDE integrations for power users. While IDE chat bars are highly accessible, advanced practitioners are migrating back to terminal-based tools (like Pi, Gemini CLI, or custom tmux setups). This shift is driven by a need for stability, as frequent, invisible updates to IDE agent harnesses often break established workflows. Terminal interfaces also prevent heavy TUI elements from disrupting scroll momentum and allow for cleaner, deterministic session rewinding.

• ⚡️Monty: the ultrafast Python interpreter by Agents for Agents — Samuel Colvin, Pydantic
• Pi Day: AMA with Pi's Creator + Talks & Extensions Deep Dive
• Pi Day: AMA with Pi's Creator + Talks & Extensions Deep Dive

Dissenting Views

• The scalability of sub-agent swarms. Tools like Cursor heavily market the ability to spin up to 20 parallel agents on isolated cloud VMs to increase throughput and autonomous code generation. However, several veteran practitioners strongly argue that sub-agent swarms are an anti-pattern for complex software. They note that swarms simply shift the bottleneck, dumping tens of thousands of lines of concurrent code onto a single human reviewer—a scale the human brain cannot critically evaluate, leading to merge conflicts and slop.
• AI Made Every Company 10x More Productive. The Ones Cutting Headcount Are Telling on Themselves.
• Pi Day: AMA with Pi's Creator + Talks & Extensions Deep Dive

• How to Automate ANYTHING with Claude Code (as a normal person)

• The necessity of long-term agent memory. Methodologies like "Compound Engineering" advocate for actively extracting session metadata, learnings, and preferences into external files to build persistent agent memory over time. Conversely, other framework creators view long-term agent memory as redundant and prone to context rot. They argue the codebase itself is the ultimate source of truth, and agents are better off dynamically exploring fresh repository state on every run rather than relying on parallel memory layers.

• Compound Engineering Camp: Every Step, From Scratch
• Pi Day: AMA with Pi's Creator + Talks & Extensions Deep Dive

Read & Act

What to read - Slop Creep: The Great Enshittification of Software — This is essential reading for understanding the subtle, compounding dangers of agent-invented abstractions. It provides a rigorous framework for how to act as a system architect when reviewing AI output. - Comprehension Debt — the hidden cost of AI generated code. — Offers a vital conceptual framework for why traditional code review and testing fail at agentic speeds. It perfectly articulates why "green tests" no longer guarantee a maintainable codebase. - ⚡️Monty: the ultrafast Python interpreter by Agents for Agents — Samuel Colvin, Pydantic — A highly technical, unvarnished dive into why lightweight "code mode" execution beats heavy sandboxing, complete with excellent personality profiles of how major coding models actually behave in practice.

What to do - Adopt an STR (Skills, Tools, References) compaction strategy. Stop feeding agents raw directories. Build a claude.md or equivalent project file, and format your standard agent tools with YAML headers containing a name and description. Force the agent to scan only the YAML metadata first, expanding full files only when necessary to drastically reduce token waste. - Implement "One-Way Door" constraints. Before invoking any coding agent, identify the irreversible architectural decisions (database schemas, core interfaces, boundaries). Write concrete code snippets for these data models yourself and explicitly inject them into the initial prompt, treating the agent strictly as an implementer of your boundaries. - Shift code review to a fast-model pipeline. Don't use your expensive, highly analytical models for initial code audits. Pipe your pull requests through a model capable of full-diff ingestion (like Gemini 2.5 via CLI) for a fast, 90-second initial review to catch glaring logic errors before handing the refined code over to a human for architectural comprehension.