The 12 Leverage Points of Agentic Coding
Step inside your agent's context window and see your codebase through its eyes. Master Core Four plus 8 Through-Agent leverage points to maximize not what you can do — but what your agents can do for you.
Course Currency Note
This lesson was recorded when the agentic-coding toolchain was earlier. Claude Code has shipped many of Dan's “through-agent” tactics natively since: persistent memory, subagents, skills, hooks, MCP. The principles still apply — verify before building what Claude ships for free.
Tactic #2 — Adopt Your Agent's Perspective
The Rule
Your agent is brilliant, but blind. Every new session starts as a blank instance — ephemeral, no context, no memories. If you want your agent to perform the way you would across your codebase, it needs your perspective: the information, tools, and resources you would use to solve the problem at hand.
Two Types of Leverage Points
In-Agent (The Core Four)
Internal to the agent. These four variables are always present in every session. They set the ceiling for what the agent can accomplish before it touches anything external.
Through-Agent (External 8)
External things your agent interacts with. These extend what the agent can accomplish beyond its own window — structured data, planned workflows, reusable patterns, measurable outcomes.
In-Agent Leverage — The Core Four
Points 1–4. These are always with your agent. Tune them first before reaching for external leverage.
Everything the agent can see in its context window. The defining question: can the agent see everything it needs to complete the task successfully? CLAUDE.md, memory files, prior output, and file ownership all live here.
Which LM executes. Sets the capability ceiling for reasoning, tool-calling, and context window size. Choosing the right model for the task is the cheapest performance multiplier available.
The spec. Precision here multiplies output quality across the entire thread. A great prompt front-loads every constraint, example, and success criterion — eliminating iteration before it starts.
What the agent can do. File I/O, bash execution, web fetch, MCP servers, external APIs. Reliable tool execution is the prerequisite for long-running autonomous workflows.
Through-Agent Leverage — The External 8
Points 5–12. External patterns and systems your agent interacts with to extend its effective reach. Standard Out (#5) and Tests (#8) are the two highest-leverage points in the entire list — Dan's call, not ours.
Clear logging so the agent can see its own errors, successes, and state in real time. Dan calls Standard Out and Tests the two highest-leverage points in the entire list. Without it, the agent is flying blind on every run.
Classes, interfaces, schemas — structured information contracts that tell the story of how data flows through your system. TypeScript interfaces, Pydantic models, JSON schemas. Types give the agent a hard surface to reason against and reduce misinterpretation of data shape.
Written for agents, not humans. Concise, structured, and surfaced inside the agent's context window. Includes internal docs (ai_docs/ folder, CLAUDE.md files) and external (web fetch). Agent-specific docs eliminate guesswork and dramatically reduce hallucination on your own codebase.
One of the HIGHEST leverage points per Dan — paired directly with Standard Out. Tests create a closed-loop self-validation cycle: the agent writes code, runs tests, reads failures, and fixes them autonomously. Without tests, the agent has no feedback signal and you own every review cycle.
Navigable, consistent codebase structure that solves the Agent Navigation Problem: every new session wastes cycles re-exploring if the codebase is inconsistent. Clear module boundaries, consistent naming (Information Dense Keywords — IDKs), explicit entry points, and the 1000-line file size limit all amplify agent reliability.
Plans are just prompts. The quality of the plan equals the quality of the output. A well-structured plan is a high-leverage prompt that front-loads every constraint, dependency, and success criterion before a single line of code is written.
Reusable slash commands in .claude/commands/ that encode successful patterns. Three times makes a pattern — automate it. The prime command (.claude/commands/prime.md) is the canonical example: it loads full codebase context at the start of every session.
Agentic Developer Workflows: agentic prompts + deterministic code + trigger = autonomous pipeline. ADWs encode successful patterns so you never solve the same problem twice. The deterministic code layer makes them reliable; the agentic prompt layer makes them flexible.
Mastering All 12
Stack them in order. Core Four first — if the agent can't see it, the model is wrong, the prompt is vague, or the tools are missing, nothing downstream matters. Once Core Four is solid, layer in the Through-Agent points: add Standard Out and Tests first, then Architecture, then Plans and Templates, then ADWs.
Every leverage point compounds the ones before it. One-shot success is not a separate goal — it is what happens when all 12 preceding points are tuned.
Transition: AI Coding to Agentic Coding
Phase one was AI-assisted coding: you typed, the AI suggested, you accepted. You were the driver.
Phase two is agentic coding: the agent plans, codes, tests, reviews, and documents. You own the gates. The shift is not a productivity hack — it is a change in identity. We are not AI coders anymore. We adopt the agent's perspective and design the systems that make agents irreplaceable.
The 12 leverage points are the full map. Master them and the gap between what you can do and what your agents can do closes to near zero.
Phase 2 SDLC
The compressed, focused version of the software development lifecycle built for the agentic age. Each phase is a discrete agent task. You own the gates — not the code.
Agent decomposes the spec, surfaces blockers, writes a task list.
Agent writes all implementation — you do not touch the keyboard.
Agent runs the test suite, interprets failures, and fixes them.
You (or another agent) verify correctness, style, and completeness.
Agent updates READMEs, changelogs, and inline docs from the final code.
Key Concepts from Transcript
Vocabulary and mental models Dan uses throughout the lesson. These are not separate leverage points — they are the reasoning behind the Through-Agent eight.
Every new session wastes cycles re-exploring an unfamiliar codebase. Architecture (point 09) directly solves this — navigable structure is not aesthetic, it is a performance multiplier.
Verbose, meaningful names that grep well and communicate intent without surrounding context. Use IDKs in file names, function names, variables. The agent finds things faster and hallucinates less.
Tests + Standard Out = agent self-validates. The agent writes, runs, reads output, corrects, and repeats without your involvement. Closing the loop is the prerequisite for long autonomous runs.
claude -p for autonomous, unattended runs. The foundation of ADWs and scheduled pipelines. Removes the human from the execution loop entirely.
ai_docs/ is a dedicated folder written entirely for agents, separate from human READMEs. Load it into context at session start via the prime command.
If you do something manually three times, automate it as a template or ADW. This is the compounding heuristic behind the Templates leverage point.
Keep every file under 1000 lines. Files that exceed this limit become difficult for agents to navigate and reason about. Split proactively.
The quality of the agent's plan equals the quality of the agent's output. Invest in planning as you would invest in prompting — they are the same act.
AI Developer Workflows (ADWs)
ADW Formula
agentic prompts + deterministic code = reusable workflowADWs encode successful patterns so you never solve the same problem twice. The deterministic code layer makes the workflow reliable; the agentic prompt layer makes it flexible. Together they produce a system that scales without babysitting.
Agentic Coding KPIs
If you are not measuring, you are not improving. Dan's four KPIs measure agentic leverage directly — not lines of code, not story points.
| KPI | Direction | Meaning |
|---|---|---|
| Size | ↑ | Size of work handed off in one agentic prompt. Larger chunks = higher leverage. |
| Attempts | ↓ | Re-prompts needed to correct mistakes. High attempts signal a missing leverage point upstream. |
| Streak | ↑ | Consecutive back-to-back one-shot successes. The compounding proof of a tuned system. |
| Presence | ↓ | How much the engineer has to sit, guide, or correct. Target: zero. |
North Star: One-shot agentic coding success. Right result. First run. No correction loop. Track Streak to see it compounding.
What We Apply
These leverage points are not theoretical here. Every one maps to a running system in the ecosystem.
Every agent execution emits structured logs. Carlos dispatch reports are the Standard Out of the orchestration layer — errors, blockers, and proof are always surfaced explicitly.
Every content artifact has structured frontmatter. Agent manifests define the contract between the orchestrator and the specialist. Types tell the information story.
Every project carries a CLAUDE.md that loads into agent context at session start. The reference folder is the ai_docs/ equivalent for the ecosystem.
Queen loads every deployed page with a browser agent and scores before Carlos reports completion. Nothing ships without a verification pass.
Consistent folder conventions across all machines make the codebase navigable without exploration. The numbered folder structure is the ecosystem's IDK system.
Oliver writes the score before Carlos conducts. Every job has an objective, done-when criteria, workstreams, constraints, and success criteria before a single agent fires. Plans are just prompts.
98-skill library encoding successful patterns. Slash commands load codebase context at session start. Three times makes a pattern — every repeated workflow becomes a skill.
Five live autonomous pipelines already running. Each is agentic prompts + deterministic code + trigger. The machine runs without babysitting.