Team intro · Engineering

How we build now

The Agentic Developer Workflow at Wasteology: agents do the building, we design and approve.

Local-first · Human-gated

Wasteology

The shift in focus

Control costs speed

A ladder of abstraction from a single line of code up to a software factory. Working lower gives direct control and understanding; working higher gives speed.

Work lower for control and understanding. Work higher (products, agents, ADW) for speed. ADW moves our attention up the ladder; we drop to the code only when we need precise control. Click the image to open it full size.

What changes for us

Your leverage is the spec, not the keystrokes

Up the ladder
Specs, products, agents. This is where we spend most of our time now, and where the speed comes from.
Down the ladder
Lines, functions, files. We still go here, on purpose, when a change needs precise control and understanding.

We stop typing most lines by hand. The skill becomes writing a clear spec and reviewing the result well.

Why it works for us

What we already have

20+
projects managed from one interface (the ops CLI registry)
7
specialized tools orchestrated by that one CLI
100%
of changes land as a draft PR a human merges
Local-first
runs on flat, unmetered subscriptions before any metered spend

One terminal

One CLI orchestrates every tool

The ops CLI at the center, with spokes to Azure DevOps, Azure, Prefect, dbt, Sling, n8n, and HubSpot.

One operator drives every tool without leaving one interface. ops doctor literally checks the "child CLIs."

Azure DevOpsAzurePrefectdbtSlingn8nHubSpot

Self-resolving software

Users ask the app to improve; ADW builds it

A closed loop: a user requests a change in the app, the app dispatches a spec, ADW builds it and opens a draft PR, a human merges, and the fix deploys back to the app.
  1. A user in the deployed app requests a change.
  2. The app turns it into a spec and dispatches it.
  3. ADW builds it and opens a draft PR.
  4. A human reviews and merges.
  5. The fix deploys back to the app.

Live in our portal-reconciliation project. A human still merges before anything ships.

Where we're heading · not done yet

One roadmap.toml, a whole BRD

# roadmap.toml — one source of truth
[goal]
title = "Deliver the Billing BRD"

[[deliverable]] # order 10
specs = ["specs/01-auth.md"]
status = "deployed" ✓

[[deliverable]] # order 20
specs = ["specs/02-api.md"]
depends_on = ["01-auth"]
status = "validated"

[[deliverable]] # order 30
specs = ["specs/03-ui.md"] · status = "implemented"
[[deliverable]] # order 40
specs = ["specs/04-report.md"] · status = "planned"

The chain walks itself, one spec at a time:

  1. roadmap.py picks the next unblocked deliverable (by order + depends_on).
  2. Local ADW implements that spec and opens a draft PR.
  3. A human reviews and merges.
  4. roadmap.py sync advances its status: planned → implemented → validated → deployed.
  5. On to the next spec, until the goal is deployed.

The goal reached = the whole BRD delivered, every step a human-merged draft PR.

Today we run ADW one spec at a time. Next: link the specs in roadmap.toml and walk the chain automatically, syncing after every PR, until the entire BRD is built. We have the pieces (roadmap-as-code, the sync tool, the local loop); we have not yet run a full BRD end to end. That is the next frontier.

What this means for us

Aim higher up the ladder

  • Spend our time on specs, products, and agents, and go faster.
  • Drop down to the code when a change needs real control.
  • Run the whole portfolio from one terminal.
  • Every change is still a draft PR a human merges.

Local-first · Human-gated · One terminal · Self-resolving

Wasteology