Skip to main content

Module 0: Orientation

Prefer to listen? 🔊
Narrated by the Wasteology Academy guide (~1 min)

Welcome to the ADW Track. Before you install anything or run a single command, this module answers the question you should be asking: why does this exist, and what makes it safe to trust?

Why ADW exists​

The Agentic Developer Workflow (ADW) turns a task or spec into an implemented, PR'd feature — run by Claude Code agents, gated by humans. It has two entry points: automated (Tirion proposes a recommendation, which a human accepts) or manual (ops digest add-task). Either way, the same loop runs afterward, and the same human gate sits at the end of it.

The reason this matters isn't "agents can write code" — plenty of tools do that. It's that ADW is built to make agent-written code safe to merge without babysitting every line, by structuring the work so an agent can't quietly skip steps or grade its own homework.

Architecting the Agentic Development Workflow (ADW) — overview (NotebookLM-generated)
Watching the video

This overview was generated with NotebookLM and uses some vivid framing to make the architecture memorable. Where it does, the rest of this track pairs that framing with the exact mechanism behind it — starting right now, with the two big ideas.

The two big ideas​

Everything else in this track is a variation on these two ideas. Learn them now and the rest of the track will make a lot more sense.

Idea 1 — Spec-first​

An ADW task doesn't start with an agent improvising against a vague prompt. It starts with a spec: a written description of what should change and why. That spec gets planned, and the plan itself gets reviewed — by another agent acting as a critic — before implementation starts. Writing the spec down first is what lets a different pass later check the work against something concrete, instead of checking the work against its own memory of what it meant to do.

You'll write your first spec in Module 3.

Idea 2 — The human safety gate​

No matter how the loop runs — locally on your subscription, or in one of the cloud execution models — it ends the same way: a draft pull request and a human merge gate. ADW does not auto-merge by default. A person looks at the diff and presses merge. This is the one mechanic that is non-negotiable across every environment this track covers.

Inside that loop there's a second, less visible gate worth knowing about now: an independent maker-checker verifier sits between "implement" and "commit," and refuses to let unverified or unfinished work reach the PR in the first place. The idea in one line: the maker no longer grades its own homework. You'll run this gate yourself in Module 4.

ADW: The Agentic Development Workflow (framework infographic — NotebookLM-generated, illustrative)
ADW: The Agentic Development Workflow (framework infographic — NotebookLM-generated, illustrative)
Reading the infographic

Infographics like this one are generated to be visually memorable, and some of their phrasing (multi-dimension "quality gates," architecture metaphors, and the like) is illustrative rather than a literal description of the code. The mechanics this track will actually show you running are: the draft-PR + human merge gate, the independent maker-checker verifier, evidence/RESULTS.md gating (Module 5), lat.md grounding (Module 2), and the local-vs-cloud execution split (Module 6). When in doubt, trust this text over the artwork.

Wastey says

If you remember nothing else from Module 0, remember this: spec first, human merges. Every other module is either building toward that loop or showing you what happens around its edges.

Hands-on lab​

You won't touch a terminal yet — this lab is about orienting yourself in the ecosystem before you start running commands in Module 1.

  1. Re-watch (or skim the transcript of) the overview video above and write down, in your own words, one sentence each for: what a spec is, and what the human merge gate does.
  2. Skim the ADW quick-start in the Company Docs. You don't need to absorb every detail — this track will cover it in depth — but note the 5-step pipeline shape so it looks familiar when Module 4 walks through the real thing.
  3. If your team already has an ADW-enabled project, ask a teammate to show you one merged PR that ADW opened. Notice that it's a normal PR: a diff, a description, and a human's approval — not a mysterious black box.

Explore the ADW loop​

Click each stage to see what happens and who owns it.

The ADW loop, end to endInteractive

Click any step to see what happens and who's responsible.

▸So what does the human actually own?

Knowledge check​

What are the two entry points into an ADW task?
What happens by default when ADW finishes implementing a change?
What does the maker-checker gate mean in practice?

Next up: Module 1 — Claude Code locally.