Lesson 7: Zero Touch Engineering

Tactical Agentic Coding

The one tactic: Target Zero Touch Engineering — invest so deeply in your Agentic layer that a single prompt ships a whole problem class to production with no human review.

Overview

This is the edge of agentic coding: a codebase that nearly runs itself. Once you have built the system that builds the system, it pays you back massively. In this lesson five net-new pieces of work (chores, bugs, and features) are handed to an Agentic layer that ships them end to end — plan, build, test, review, document — in parallel, in isolated environments, on a single device.

There are three levels on the Agentic engineering velocity scale. In-loop: you at the keyboard, prompting back and forth. Out-loop: a high-level prompt fired through the Peter framework, running AFK on an isolated device. Zero Touch Engineering (ZTE): you drop yourself off the end of the loop entirely — Peter becomes Pete, no review — and let the agent ship to production.

You do not start by shipping full features to prod. Progress happens one step at a time: first chores, then bugs, then features. Solve the stupid, simple, time-wasting problems first, prove your ADWs can ship them, and scale up. Think in the gray — it is not in-loop versus out-loop, it is in-loop moving toward out-loop, one day at a time.

The real challenge of this lesson is belief. You have to believe the Agentic layer is worth investing in. If you bet big on it, you will reach the moment where human-in-the-loop review stops catching bugs and becomes a bottleneck — and that is when you drop the review.

The velocity ladder

flowchart LR
    A["In-loop
you at the keyboard,
prompting back and forth"]
    B["Out-loop
Peter framework,
AFK on isolated device"]
    C["Zero Touch Engineering
Pete (no review),
ships to production"]
    A -->|"template your
engineering"| B
    B -->|"proven, repeatable
problem class"| C
    C -.->|"presence drops
to 1"| C

Key concepts

Peter → Pete

The Out-loop system runs on the Peter framework: Prompt input, Trigger, Environment, Review. When you get so good at shipping a class of work that review adds no value and only slows you down, you drop the R. Peter becomes Pete. That is ZTE — YOLO / maximum-confidence mode for your AI developer workflows. Just as you stopped coding, you stop reviewing. The best Out-loop agent coders have a presence of two (prompt + review); ZTE drops presence to one.

The KPIs at ZTE

• Attempts at 1 — one prompt ships the work.
• Size constantly scaling up.
• Streak constantly increasing — problem classes shipped back to back with one attempt each.
• Presence dropped to 1 — the agent ships end to end.

Git worktrees for parallelism

To run many pipelines at once on one device, each workflow creates its own isolated Git worktree — a full copy of the codebase (env vars, Playwright config, ports) for one agent to build in. slash install-worktree sets up the tree with created ports and a worktree path. It does not matter whether you use worktrees, VMs, Docker, or agent containers — only that you can isolate and parallelize, and can quickly plug into any environment (code trees/<id>) to see what an agent is doing. Lesson 6's tactic is not broken: still one agent, one prompt, one purpose per tree, with a state.json threading meta-information through so you can replay any agent's run.

The model-set knob (base / heavy)

model_set is an information-dense keyword (IDK) — a knob that changes which set of models runs a workflow. agents.py maps each slash command to either a base model or a heavy model (e.g. heavy forwards to Opus). Passing heavy at the top level, parsed by the classify-adw step, scales compute for larger features. This stacks with the think hard IDK already encoded in prompts to activate reasoning. You can encode any IDK you want as long as your prompts and ADWs pick it up.

The secret: composable primitives, not the SDLC

The secret of Tactical Agentic Coding is that it is not about the software developer lifecycle at all — it is about composable agentic primitives you can use to solve any engineering problem class. Plan-build-test-review-document is powerful and relevant, but it is a package to deliver a message, not the optimal or only arrangement. The arrangement of ADWs is arbitrary; the one right way is the way that ships in your codebase. You are not solving one-off problems anymore — you are composing and orchestrating intelligence over problem classes, all the way down to the prompt and Claude Code, all the way up to how you organize ADWs.

How to apply it

1. Fire multiple issues (varied difficulty) at your Out-loop system and let ADWs pick them up in parallel.
2. Give each workflow its own isolated environment — Git worktree, VM, or container — with install-worktree cloning env, config, and ports.
3. Thread a state.json through every pipeline so you can jump into code trees/<id> and replay any agent.
4. Add a model_set knob (base/heavy) mapping commands to models; pass heavy for large features, base for cheap chores.
5. Keep proving each problem class end to end until you trust it — review images/video are your proof of value.
6. Start ZTE small: ship a class of chores (styling, background color, DB migrations) with ADW-SDLC-ZTE-ISO.
7. Let ship merge the feature branch into main and deploy — no human review — once confidence is high.
8. Scale up one step at a time: chores → bugs → features. Spend your time improving the Agentic layer, not solving the problem directly.

Commands & conventions

Command / ADW	Purpose
ADW-SDLC-ISO	Full SDLC (plan, build, test, review, document) in an isolated worktree
ADW-SDLC-ZTE-ISO	SDLC + ship (approve, merge, deploy) — zero touch
ADW-ship-ISO	Checkout main on root, merge feature branch, post success
ADW-patch-ISO	Simple isolated cleanup (e.g. text mismatch)
slash install-worktree <ports> <path>	Provision an isolated worktree copy of the app
slash classify-adw	Parse base/heavy model, ADW ID, and slash command up front
slash in-loop-review <branch>	Pull branch, reset DB, restart app, review by hand

Conventions:

adws/            # SDLC-ISO, SDLC-ZTE-ISO, ship-ISO, patch-ISO
agents.py        # slash command -> base | heavy model map
trees/<id>/      # isolated Git worktree per agent (full app copy)
state.json       # branch, ADW ID, ports, meta info threaded through

Information-dense keywords in play: heavy (model set), think hard (reasoning mode). Encode any IDK your prompts recognize.

Key takeaways

• The velocity ladder: in-loop → out-loop → Zero Touch Engineering.
• ZTE = drop the review; Peter becomes Pete; presence drops from two to one.
• Start ZTE on small, easy-to-validate work (chores) and scale up to bugs then features.
• Git worktrees (or VMs/Docker) let many one-purpose agents run in parallel, isolated, replayable.
• The model_set knob (base/heavy) scales compute per workflow; it is just an IDK your prompts pick up.
• The secret: it is not about the SDLC — it is about composable agentic primitives for any problem class.
• The arrangement of ADWs is arbitrary; the right arrangement is the one that ships in your codebase.
• The real hurdle is belief — invest in the Agentic layer and become the engineer they can't replace.

Notable quotes

"This human in the loop model is a bottleneck. I'm not catching any bugs anymore."

"It becomes Pete, not Peter. You'll drop off the review."

"The secret of tactical agentic coding is that it's not about the software developer lifecycle at all. It's about composable agentic primitives you can use to solve any engineering problem class."

"Don't run toward the future, don't walk toward it, sprint into the future."