Lesson 3: The 80/20 of Agentic Coding — Template Your Engineering

Tactical Agentic Coding

The one tactic: Template your engineering — encode your problem-solving into reusable meta-prompts that generate full plans, so your agent writes the first (and often final) draft of the work and you stop hand-writing plans.

Overview

The prompt is everything — it is the medium through which you communicate to every agentic tool. A scaled prompt is a plan (a spec, a PRD). Plans are prompts scaled up for high impact: the plan is the prompt, and great planning is great prompting.

But planning by hand is expensive, time-consuming, and error-prone, and the cost scales with the difficulty of the problem and the size of the codebase. There's always something to miss. The 80/20 solution is to take your successful plans and convert them into templates — one of the 12 leverage points — that encode your engineering into reusable units you, your team, and your agents can see, use, and improve.

This is the third tactic, stacked on the first two: first you stop coding, then you adopt your agent's perspective, and now you template your engineering. Templates give you consistent results across hundreds of agent executions regardless of codebase size — one of many answers to the "my codebase is too big" problem.

The lesson works through three prompt types — meta prompts, templates, and higher-order prompts (HOPs) — using /chore, /bug, and /feature on a natural-language-to-SQL app, and it makes the case for running a fresh agent per SDLC node.

Key concepts

Plans are prompts scaled

A plan is just a large prompt saved to specs/. It is a staging environment for code that will be generated — engineering work compressed into natural language that the agent will later expand. Saving plans creates artifacts you, your team, and your agents can reference and improve.

Meta prompt

A prompt that builds a prompt. /chore, /bug, and /feature are agentic prompts that read a template, inspect the codebase, and generate a full plan from a single high-level sentence. You write a low-information, high-level prompt; the agent expands it into a detailed spec.

Template

The reusable structure a meta prompt fills out. Every good template contains a purpose at the top, then instructions, relevant files, a plan format, and finally the argument (the chore/bug/feature you passed in). The generated plan mirrors the format exactly (e.g. description → relevant files → step-by-step tasks → validation commands → notes).

Higher-order prompt (HOP)

Like passing a function into a function — a prompt that takes another prompt as an argument. /implement <plan> is a HOP: it reads the plan you pass, thinks hard, executes it, then reports. You can write richer HOPs (implement → then review the work against the plan) to shape repeatable success.

The plan → implement split

Work is done in two separate agent runs: one meta prompt to plan (writes the spec) and one HOP to build (implements the spec). The implement prompt is tiny — read the plan, think hard (activating the reasoning model), execute, and report files changed. Validation commands embedded in the plan (running pytest, running the server) create self-validating closed loops where the agent checks and fixes its own work.

Why fresh agents per node

Boot a brand-new agent for each SDLC step — no shared memory. Three reasons:

1. Free context. One agent, one task, focuses every token on the mission (critical for large codebases and long runs).
2. Isolated, reusable, improvable assets. Forcing zero dependencies means every template and plan is a self-contained unit you can debug — you know exactly what was in the context window.
3. Prepares for off-device agentic coding. Decoupling performance from a long conversational context is what lets you one-shot work autonomously and drive Presence to zero.

How to apply it

1. Generate a plan from one sentence. Run /chore "<high-level ask>"; the agent inspects the codebase and writes a full spec to specs/.
2. Read the template in .claude/commands/ to see how purpose + instructions + relevant files + plan format shape the output.
3. Implement in a fresh agent. Open a new Claude instance and run /implement specs/<plan>.md.
4. Let the closed loop run. The plan's validation commands run tests and smoke-check the app; the agent fixes issues it finds.
5. Scale to bugs and features. Use /bug for defect specs (problem/solution statements, steps to reproduce, root-cause analysis) and /feature for net-new work (user story, implementation phases, edge cases, acceptance validation).
6. Specialize templates as the codebase grows — a front-end-feature template, a DB-migration chore, a notebook bug resolver. The more custom the template, the more differentiated your engineering.
7. Improve the system, not the output. When a plan misses, tweak the template or HOP, not just the one result.
8. Rehearse off-device. Fire /feature via claude -p and stream the result to a file to feel true autonomous execution.

Commands & conventions

Command / path	Purpose
/install	Reusable setup; here also runs scripts/copy.* to reuse prior .env
/chore "<ask>"	Meta prompt → generates a chore plan in specs/
/bug "<ask>"	Meta prompt → generates a bug-fix plan (repro, root cause, new files)
/feature "<ask>"	Meta prompt → generates a net-new feature plan
/implement <plan>	Higher-order prompt → reads the plan, think hard, executes, reports
.claude/commands/	Home of all templates / reusable prompts
specs/	All generated plans are written here
think hard	Information-dense keyword that activates the reasoning model

# Plan then build, each in a fresh agent instance
/chore "replace all server print statements with proper Python logging"
/implement specs/replace-print-with-logging.md

# Off-device rehearsal: run a template in programmable mode, stream to a file
claude -p "/feature 'add a query history side panel'" \
  --output-format stream-json \
  --dangerously-skip-permissions \
  --model <best-model> --verbose > run.jsonl

Key takeaways

• The prompt is everything; a scaled prompt is a plan, and the plan is the prompt.
• Templates encode your engineering into reusable units for you, your team, and your agents.
• A meta prompt builds a prompt; a higher-order prompt takes a prompt as an argument.
• Split work into plan (/chore, /bug, /feature) and build (/implement <plan>).
• Embed validation commands in every plan to create self-validating closed loops.
• Run a fresh agent per SDLC node — free context, isolate assets, prepare for off-device work.
• Almost anything can be templated: chores, bugs, features, refactors, notebooks, new codebases. "My codebase is too big" is a limiting belief.
• Fix the system that caused the miss (the template/HOP), not just the individual output.

Notable quotes

"Plans are prompts scaled up for high impact. The plan is the prompt, and that means great planning is great prompting."

"Not only should we stop coding, we should also lean into and leverage our agent to write plans with us and for us."

"We build the system that builds the system."

"Be very careful thinking that these tactics can't work for you… that is a limiting belief."