Foreman

The deciding trait is that it stops. Design ends at a review you have to answer, and only then does the building start. If your problem is that agents run off with the wrong idea, a gate placed exactly there is the fix.

If your problem is that you want to walk away, the gate is a leash you did not ask for. Pick it when the work is worth specifying and you will be at the desk to approve it. Pick a plain agent when you would rather come back to a diff.

The coupling is total. The pipeline drives a single named CLI, in a single output mode, by parsing the event format that mode emits. Three separate dependencies on one company, any of which can change in a minor release, and none of which has a fallback described in the documentation.

Parsing another program's stream is the fragile part specifically: an added field is harmless, a renamed one is a silent failure in the middle of a build phase. What it does right is being narrow on purpose: one CLI deeply understood beats five shallowly wrapped, and the parsing is only possible because it chose one.

1. The structure is the argument. Each stage produces a document the next stage consumes, so the system's reasoning is externalised at four points rather than held in a context window, and a wrong turn is visible in a file before it becomes visible in code.

2. Test-driven construction supplies the verification the other stages lack.

3. Whether the tests are written before the implementation by the same agent that then satisfies them is the question the documentation does not answer, and it decides whether this is verification or tautology. No evaluation is published. The architecture is the most disciplined on this shelf and the least measured.

The addressable market is a subset of another company's subscriber list, which is a hard place to raise from. There is no revenue line, no hosted tier and nothing to sell, so the entity behind it is a name rather than a business. Moat: none, and the dependency makes one structurally impossible.

Likely path: the vendor ships a pipeline of its own, or this stays a well-regarded niche tool with a devoted few hundred users. Neither outcome hurts anybody, because nothing is hosted and nothing is billed. Position: adopt it freely, and treat it as a workflow you could rebuild rather than a supplier.

A budget the tool enforces is worth more to me than any capability in the row. Everything else on this shelf tells me what was spent; this refuses to spend past a number I set, which converts an open-ended liability into a line item. Across sixty engineers that matters.

It also runs unattended, so it can be a pipeline step rather than a desktop habit, and it installs from a package index we already mirror. No single sign-on, no directory sync, no audit export. Approved with conditions: budgets set centrally, the package pinned in our index, and a named owner for every repository it runs against.

A badge is not a licence. When the repository does not resolve to a recognised identifier, every automated check in my toolchain treats it as unlicensed, and I have to decide by hand whether a fork is permitted. For a project this careful about its own process, leaving that ambiguous is a strange omission.

The model question is closed too: one vendor, no substitution, and the row says so plainly. There is no protocol surface either, so nothing I built attaches. Grudging respect for the discipline of the thing, and none at all for how little of it I could make my own.