Lesson 8: The Agentic Layer

Tactical Agentic Coding

The one tactic: Prioritize agentics — spend more than half your engineering time building the Agentic layer that operates your codebase for you.

Overview

This final lesson cements the ideas of the course by revisiting the atoms of agentic engineering and showing how they compose across different codebases. The tactics are not bound to the software developer lifecycle or any specific workflow — they are building blocks you compose into repeatable solutions for your agents.

Picture a ring around your codebase. At first the Agentic layer is thin. As you scale agentics into it, the ring thickens — machines that operate with your judgment, ship your way, and get work done autonomously in your product. This is where you template your engineering and teach your product to build itself.

The final tactic has been staring at us the whole time: prioritize agentics — more specifically, prioritize your Agentic layer. It compresses every other tactic, from "stop coding" all the way to "target zero touch engineering." As a rule, at least half your engineering time should go to the Agentic layer, with heavy upfront investment when you start.

Then, at the very end, a single guiding question compresses the entire course into one daily check.

The Agentic layer ring

flowchart TB
    subgraph RING["Agentic layer (the ring you thicken)"]
      direction TB
      ADW["ADWs — highest composition:
deterministic code + agentic prompts"]
      PR["Prompts / templates / meta prompts
(.claude/commands)"]
      SP["Specs / plans (markdown)"]
      TR["Triggers — Peter: prompt input,
trigger, environment, review"]
    end
    subgraph APP["Application layer"]
      direction TB
      A1["Raw application"]
      A2["Database"]
      A3["Infra / DevOps"]
    end
    RING -->|"operates on"| APP

Key concepts

Agentic layer vs application layer

There are two layers. The application layer is deliberately broad — raw application, database, infrastructure, DevOps. The Agentic layer is the ring around it: the combination of traditional deterministic code (stored as a scriptable ADW layer) fused with the new non-deterministic agentic technology (the language model, Claude Code, and whatever comes next). More than half your time belongs on the Agentic layer, because by investing there you are actually investing in the application layer — and ultimately in your users, product, and company.

The Minimum Viable Agentic Layer

You need only three pieces to start:

1. An ADW directory — a scripting layer (UV single-file scripts, Bun, or shell — it does not matter) that can reference other files and stays isolated from apps/.
2. Prompts — markdown prompts in .claude/commands (prime, start, implement, and template meta prompts for chore/feature/plan).
3. Plans / specs — markdown, generated by your template meta prompts.

The thinnest layer is a single adw script that calls one Claude Code agent and manages surrounding state. From there you stack: run a slash command from a script (slightly out of the loop), then chain prompts into real workflows (e.g. chore → implement), then compose arbitrary code + agentic prompts. Investing here is parabolic: put ten minutes in, get two hours of value out.

The ADW ladder (composition levels)

flowchart LR
    P["Prompt
(in-loop)"] --> S["Slash command
via script"]
    S --> C["Chained ADW
(chore → implement)"]
    C --> M["Composed multi-step ADW
(plan → build → test → review → document)"]
    M --> T["Triggered / multi-agent
(cron, worktrees, ZTE)"]

The four example codebases in this lesson show the same atoms at different thicknesses: an empty primitive starter; a multi-agent to-done system driving data-science work across worktrees from a tasks.markdown file; an agentic prototyping app picking up tasks from a Notion board via cron trigger and building whole MCP servers from one prompt; and a natural-language SQL app with agents (Nexus, Roon) embedded directly inside the application server — the one place the "one agent, one prompt, one purpose" rule is broken by passing a session ID back in to continue a conversation.

The single guiding question

If you forget all eight tactics, keep this one daily check:

Am I working on the agentic layer, or am I working on the application layer?

The majority of your time should be on the Agentic layer. If you are on the application layer, you must have a good reason — a deadline, or testing that a prompt works in-loop before running it out-loop — or you are moving in the wrong direction.

Recap: all 8 TAC tactics

1. Stop coding — the irreplaceable engineer writes no code; adopt your agent's perspective and give it the right context, model, prompt, and tools.
2. Adopt your agent's perspective — layer on the 12 leverage points (in-agent core four: context, model, prompt, tools; through-agent: standard out, types, documentation, tests, codebase architecture, plans, templates, ADWs) at the right time and place.
3. Template your engineering — encode workflows into template meta prompts (prompts that output prompts) that scale to any codebase.
4. Improve your Agentic Coding KPIs — attempts down, size up, streak up, presence down.
5. Always add feedback loops (Lesson 5) — validation commands so agents self-validate and auto-improve.
6. One agent, one prompt, one purpose (Lesson 6) — focused, reproducible, testable, improvable agents.
7. Target Zero Touch Engineering (Lesson 7) — thicken the layer until review is a bottleneck; Peter becomes Pete.
8. Prioritize agentics (Lesson 8) — the Agentic layer is the highest-ROI area; spend most of your time there.

How to apply it

1. Separate your codebase into an Agentic layer (adws/, .claude/, specs) and an isolated application layer (apps/).
2. Stand up the Minimum Viable Agentic Layer: one ADW script, prompts, and plans.
3. Add a prime and start command so agents can understand and boot your codebase.
4. Write template meta prompts (chore, feature, plan) that research the codebase and output a plan in a fixed format.
5. Chain prompts into ADWs (e.g. chore → implement), then compose multi-step workflows.
6. Add triggers (cron, task file, Notion board) to move from in-loop toward out-loop and ZTE.
7. Use isolated environments (Git worktrees) to run many one-purpose agents in parallel.
8. Every day, ask the single guiding question and steer your time toward the Agentic layer.

Commands & conventions

Piece	Purpose
slash prime	Set the agent up: understand the codebase quickly
slash start	Boot the application (UV run + Bun run)
slash implement <plan>	Higher-order prompt: take a plan, implement it
slash chore / slash feature / slash plan	Template meta prompts that output plans
adw script	Thinnest layer: call one Claude agent + manage state
chore-implement ADW	Run chore template, then implement the plan
cron trigger	Poll a task source (file / Notion) to stay out-loop

Minimum Viable Agentic Layer:

adws/            # scripting layer (UV / Bun / shell) — isolated from apps
.claude/commands/  # prime, start, implement, chore, feature, plan
specs/           # generated plans (markdown)
apps/            # application layer — kept separate from the agentic ring
agents/ + logs/  # per-agent traces of work done
ai_docs/         # third-party docs to paste in as needed

Key takeaways

• Two layers: the Agentic layer (the ring) operates the application layer (raw app, DB, infra).
• Prioritize agentics — spend at least half your engineering time on the Agentic layer.
• The Minimum Viable Agentic Layer is three pieces: ADWs, prompts, plans.
• The atoms are prompts; they compose up through templates, ADWs, triggers, and multi-agent systems.
• Investment in the Agentic layer is parabolic — small input, large repeatable output.
• Solve problem classes, not one-off fixes — one prompt solved "build an MCP server" forever.
• The single guiding question: am I working on the agentic layer or the application layer?
• Coding — and increasingly implementation — is commoditized; value moves up to system design, review systems, and creative problem decomposition.

Notable quotes

"Build the system that builds the system."

"Prioritize agentics. Prioritize your agentic layer."

"Am I working on the agentic layer or am I working on the application layer? That's it."

"When the agents arrived, something changed. We weren't just AI coding anymore. We started orchestrating intelligence."