Agentic Coding

Briefing: Agentic Coding

Purpose: Practical 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 harness is the product, not the model. Multiple independent sources converge on the same conclusion: agent differentiation lives in the integration layer — compaction templates, prompt cache management, security sandboxing, permission systems, and cost tracking — not in the underlying LLM. Claude Code's 9-section compaction template, per-turn aggregate token budgets, prompt cache splitting (yielding 90% cost reduction on hits), and multi-layered shell security via Tree-sitter AST parsing represent thousands of engineering hours. Ben Thompson argues that Opus 4.5's leap came from harness changes, not the model release itself, and that profits will flow to integrated, not modular, parts of the value chain. For practitioners, this means: invest engineering time in your harness layer. The model will improve underneath you; the plumbing you build is your moat.
• The plumbing behind Claude Code
• Agents Over Bubbles | Stratechery by Ben Thompson

• "We're Not Writing Code by Hand Anymore. That's Over." | Owen Jennings & David Haber - The a16z Show

• Context engineering is your highest-leverage craft skill — and you're wasting 30-40% of your tokens on redundant input. Documentation overlaps with code comments; FAQs repeat support tickets; API docs echo tutorials. The fix isn't prompt tweaking — it's upstream preprocessing. The meta-MCP pattern claims 88% token reduction through deterministic deduplication, and Claude Code's architecture demonstrates the pattern in practice: disk-persisted large tool outputs (model gets a preview + file path, not the full blob), per-message aggregate budgets preventing parallel tool calls from dumping 200K characters into one turn, and a 3-tier memory system (project CLAUDE.md, user ~/.claude/CLAUDE.md, auto-memory with relevance retrieval). Audit your context pipelines now — the redundancy figure alone should alarm you.

• AI Agent stack you need Context, Auth, and Cognitive Debt

• The plumbing behind Claude Code

• Cognitive debt is more dangerous than technical debt, and traditional code review is already broken at scale. At one organization, 88.5% of merged PRs are agent-authored — and a senior engineer reviewing that code line-by-line discovered the junior who prompted it ignores the feedback because "it's not actionable." When nobody on your team wrote the code and nobody understands it, you don't have tech debt — you have cognitive debt, which requires active effort to rebuild understanding. The fix: shift review from code diffs to specifications and prompts, run mandatory "explain this to me" sessions where engineers walk through agent-authored code, and track outcome metrics (fewer bugs, user satisfaction) rather than output metrics (% agent-written, PRs merged). Linear's CEO reinforces: measuring PRs merged is a vanity metric without quality counterbalances.

• AI Agent stack you need Context, Auth, and Cognitive Debt
• Chip Huyen: Building when it feels like there's nothing left to build - The Pragmatic Summit

• How Linear Turned AI Agents Into First-class Users

• Coding agents work because code provides verifiable reward signals — understand this to calibrate your expectations. François Chollet explains that agents succeed in code specifically because compilation and unit tests create trustworthy feedback loops enabling effective reinforcement learning. Models aren't more "intelligent" — they're better trained via trial-and-error in post-training environments with true reward signals, and they've learned to embed models of code execution (tracking variable values mentally). This is why code was "the first domain to fall" and why progress on tasks like essay writing remains slow. If your domain can't be formally verified, expect agent performance to plateau; if it can, expect automation to accelerate rapidly.

• François Chollet: Why Scaling Alone Isn't Enough for AGI

• Skills (agent-readable markdown files) are replacing ad-hoc prompts as the standard substrate for reusable agent workflows — and the 80/20 rule for writing them is non-obvious. Anthropic, OpenAI, and Microsoft have converged on a shared file format. The critical insight: spend 80% of your attention on the description field (it's a routing signal, not a label — if the trigger doesn't fire, nothing else matters) and 20% on general reasoning. Include frameworks and quality criteria, not just linear steps, to prevent brittleness. Frame output as a contract (what the agent will receive, what it won't, what it enables) and design for composability where each skill's output hands off to the next agent. Skills compound through refinement; prompts evaporate. Convert any task you do weekly into a skill.markdown file.

• Anthropic, OpenAI, and Microsoft Just Agreed on One File Format. It Changes Everything.

Emerging Patterns

• Specialized multi-agent systems consistently outperform single general-purpose agents, but the right level of complexity is actively debated. Claire Vo's experience running 9 specialized OpenClaw agents (work vs. family vs. sales domains) confirms that segmenting by responsibility domain prevents context overload — a finding echoed by the three-tier orchestrator/lead/worker architecture using YAML config and domain locking for large codebases. The self-review loop pattern (weekly agent self-review + bi-weekly "manager" agent grading with A/B/C scores) represents an emerging practice for autonomous quality. Cross-agent memory via shared files enables coordination where feedback to one agent is implicitly understood by others. Start with domain specialization and read-only expertise files before attempting full orchestrator hierarchies.
• One Agent Is NOT ENOUGH: Agentic Coding BEYOND Claude Code
• The 5-Step Framework for AI Agents That Improve While You Sleep | E2269

• From skeptic to true believer: How OpenClaw changed my life | Claire Vo

• The unsolved problem of knowledge drift between specs and code is attracting new tooling — but even the tool builders are honest about limitations. "Lat" proposes graph-based markdown knowledge bases with Tree-sitter code parsing, wiki links, RAG search, and CI-enforceable validation to keep specs and code in sync. The internal tension the creator surfaces is telling: even with all information in context, agents can fail review prompts after multiple attempts, and sufficiently complex specs are as hard for agents to parse as code itself. This honesty contrasts with most tool marketing and suggests that while spec-driven development is a promising direction, it's not yet reliable for non-localized changes in complex systems.

• Talking Lat.md With Yury Selivanov

Dissenting Views

• Simplify systems vs. build more complex multi-agent architectures (difference in emphasis). One camp argues that as models get smarter, systems should become simpler: remove scaffolding, reduce procedural prompts, shift from "how" to "what/why," and let the model handle more — the "bitter lesson" applied to agentic coding. The opposing camp insists single agents are insufficient and that three-tier orchestrator/lead/worker hierarchies with domain locking, expertise files, and YAML configs are the path to trust and scale. Both contain truth: simplify your instructions to the model while investing in structural complexity (permissions, routing, memory). The tension resolves at the harness level — simpler prompts within more sophisticated orchestration.
• Claude Mythos Changes Everything. Your AI Stack Isn't Ready.

• One Agent Is NOT ENOUGH: Agentic Coding BEYOND Claude Code

• Spend more tokens vs. optimize token usage (direct contradiction). "You are not spending enough tokens. You are wasting time doing things the old way" — a maxim from the multi-agent architecture camp that frames higher token spend as a strategic investment. This directly conflicts with data showing 30-40% of context sent to LLMs is redundant and that the meta-MCP pattern cuts usage by 88%. Linear's CEO adds that token sellers have perverse incentives to encourage more spending. The resolution: spend more tokens on agent work overall (it's cheaper than human time), but spend them well by eliminating redundancy upstream. Profligacy and parsimony aren't opposites here — they apply to different parts of the pipeline.

• One Agent Is NOT ENOUGH: Agentic Coding BEYOND Claude Code
• AI Agent stack you need Context, Auth, and Cognitive Debt
• How Linear Turned AI Agents Into First-class Users

Read & Act

What to read:

• The plumbing behind Claude Code — A code-level teardown of Claude Code's actual architecture that you can use as a reference implementation. The specific patterns (9-section compaction, per-turn aggregate budgets, disk-persisted outputs, fork cache sharing, Tree-sitter security parsing) cannot be adequately summarized and are directly applicable to building or customizing your own agent harness.

• AI Agent stack you need Context, Auth, and Cognitive Debt — Introduces "cognitive debt" as a concept distinct from technical debt, provides a 5-level maturity model for agent adoption, and names specific patterns (meta-MCP for 88% token reduction, 4-layer context stack, Rule of Two for irreversible actions) that serve as a production checklist. The maturity model alone will help you assess where your team sits and what to prioritize next.

• Anthropic, OpenAI, and Microsoft Just Agreed on One File Format. It Changes Everything. — The most thorough practical guide to building effective "skills" (agent-readable markdown workflows). The specific guidance — single-line description constraint, description as routing signal, output as API contract, 80/20 attention allocation, composability for agent handoffs — is the kind of detail that accelerates adoption from days to hours.

• François Chollet: Why Scaling Alone Isn't Enough for AGI — Read this to understand why your coding agents work (verifiable reward signals via unit tests enable RL loops) and where the ceiling is. Chollet's distinction between "better trained" and "more intelligent" will fundamentally calibrate your expectations for what agents can and cannot do, and ARC AGI V3's focus on agentic intelligence in novel environments signals where real capability gaps remain.

• Talking Lat.md With Yury Selivanov — Presents a genuinely novel approach to the knowledge drift problem via graph-structured markdown with code linking and CI-enforceable validation. The internal tension the speaker surfaces — specs can be as hard for agents to parse as code — is honest assessment you won't find in tool marketing and is worth hearing before committing to a spec-driven workflow.

What to do:

• Audit your context pipeline for redundancy this week. Pick one agent workflow you use daily, dump the full context being sent to the model, and measure overlap between documentation, code comments, and other inputs. If you find the 30-40% redundancy figure applies to your setup, implement deterministic deduplication (hash-based or rule-based) before the context hits the model. This is cheaper and more reliable than any prompt engineering fix.

• Convert your most-repeated weekly task into a skill.markdown file. Follow the 80/20 rule: invest most of your effort in the description field with specific trigger phrases and output format, include reasoning frameworks (not just steps) in the methodology, and explicitly write down every edge case you'd handle with "common sense." Test it by having the agent invoke it 10 times and measuring consistency. This is the fastest way to start compounding value from your agent workflows.

• Implement a "cognitive debt" check on your next agent-authored PR. Before merging, have the engineer who prompted the agent explain — without looking at the diff — what the code does, why the approach was chosen, and what edge cases exist. If they can't, that's cognitive debt accumulating. Use this as the basis for deciding whether your team needs mandatory architecture reviews or rotation policies for agent-authored features.