Stephen Brouhard

Delegate execution. Keep responsibility.

How I use orchestrators, specialist agents and explicit review boundaries without mistaking more automation for better outcomes.

A check counts once I've seen it fail.

This site's own audit, run first on a copy with three planted violations, then on the real pages.

$ cd planted-copy && python3 -I scripts/site_audit.py .
pages=4 external_links=32
FAIL about.html: contains em dash
FAIL method.html: first link is not a skip link to #main
FAIL work.html: 1 img without alt
$ echo $?
1
$ cd ../portfolio && python3 -I scripts/site_audit.py .
pages=4 external_links=32
$ echo $?
0

Why I work this way

I used to be the person carrying context between agents: checking every thread, piecing together what had happened. That doesn't scale, and it isn't where my judgment is most useful.

So I combine Kun Chen's Firstmate and Grok Ship with selected methods from Lauren Tan's pstack and a few controls of my own.

The loop

  1. Name the problem

    Start from a real failure. Write down what success looks like, what's out of scope and what must never happen.

  2. Scout first

    When the answer isn't obvious, an agent investigates and reports before anything gets built. Sometimes the report says stop, and I stop.

  3. Freeze the bar

    One sentence defines done. A new request becomes a new decision, not a quiet expansion of the current task.

  4. Prove it

    Evidence tied to the exact change, including checks deliberately made to fail first. An agent saying "done" isn't evidence.

  5. Approve it

    I decide what merges and what deploys, and I treat those as two separate decisions.

A lead, not a swarm

I prefer one accountable lead with specialist help when it's warranted. The lead works out whether a task needs investigation or an authorized change; specialists implement or review; everything reconciles back to one place.

Repository work follows a software path. Business, inbox and operations requests go to the relevant specialist instead of being turned into coding projects.

Delegation is a choice, not a default. A contained product like TextStack went to a single agent outside Firstmate. Work in someone else's codebase, like SSHHIP for Android, goes through their review, so their maintainer decides what lands.

The controls

PR Freeze Bar

Write the finish line in one sentence before work starts. Every review finding either maps to that sentence or gets parked for later. I commissioned it after a review loop ran for hours; an agent drafted the written skill from the lessons I passed along.

Verification plans

Expected and prohibited behavior should be written down before an implementing agent invents its own tests. I specified a template for that, covering the definition of done, the checks, failure cases and rollback. An AI agent drafted it at my direction.

Checkpoints and exact-tree evidence

Barline, the open-source harness my own agent sessions run under, keeps a frozen task contract, ties check results to the exact code tree and makes interrupted work resumable.

Documented, loaded, executed and enforced are four different things.

Field notes

Green CI that wasn't running the safety check

In a private Alderline repository, a tenant-isolation audit existed, but the way checks were routed meant some kinds of pull requests skipped it. CI went green either way, which looked like protection without providing it.

I said the audit had to run on every pull request. We split it into its own always-run check, then opened throwaway pull requests with deliberately planted violations to prove it would fail when it should. It did, on exactly the kinds of changes the old routing had missed.

When my own agent started costing me trust

In October 2026 the SMS assistant for my detailing business started looping, asking customers for details they'd already given. The diagnosis wasn't the model; it was rigid extract-and-rewrite logic wrapped around it.

I asked for two things the same day: a small production fix behind a switch that could be turned off, and a real rebuild that let the model lead the conversation with structured checks instead of piles of rules. Both went through review and tests, and switching on the rebuild was a separate, deliberate decision. Agents wrote the code under my direction.

Whether it holds up across live conversations is still being verified.

Human authority doesn't disappear

My job is to define the problem, decide scope, question the evidence, accept trade-offs and approve the actions that matter. When automation couples merging with deploying, I pull those decisions apart again.

That's the operator's instinct I bring: don't just ask whether an agent finished. Ask what happened, what it proved and what's still unknown.