Foundry: my test-first loops for AI coding agents
I decide what gets built. Agents build it, and plain code checks it.
On Navigo Bau (construction-site documentation), from the run records
- 1 Nov 2026Bau's new front end in production, 9 days after the first run of the UI loop, foundry's predecessor.
- 13 Nov 2026Foundry's first run from plan to merge: one requirement in 101 minutes, $5.19 at API prices. The run record
- 11 to 19 Nov 202615 build runs, 9 merged, 14 requirements on main, about $220 at API prices. Two merged themselves.
I'm Marcel Bierbauer-Szigeti, co‑founder and CTO of Navigo Intelligence. I built foundry, my own project, so that what a customer says in a meeting ends up as tested, merged code, with agents doing most of the work. If it breaks in production, that's on me.
- Goal in
- Plan bay
- Gate one
- Build bay
- Check bench
- Gate two
- Into production
- G1
- G1.F1
- G1.F2
Plan A goal becomes a plan and stops at gate one until it's approved.
Fig. 1 One run, step by step Each bar on the check bench is one acceptance test. The lamps are the checks.
- Yellow I decide
- Dashed Planned, not built
- Blue edge A round is running
- Green and red A check result
- Pale box A finished task, frozen
- Red frame and arrow Blame points at a task
What it has built
The UI loop, before foundry
The UI loop rebuilt the front end of Navigo Bau, which documents construction sites, in eleven runs from 23 October 2026, and it has run in production since 1 November. I'd promised the customer it would be intuitive. The day after it went live was his two-year guarantee inspection. The room was full, and I sat next to him while he clicked through it as if he'd been trained on it. Its tasks, run by run, are drawn on the design page.
Foundry on Navigo Bau
I built foundry because I was spending my days restarting and steering agent sessions instead of deciding what to build. I started it on 1 November 2026, the day the new front end went live. I build everything with Claude Code sessions, and foundry was no different: design notes first, code two days later. Its first build run on Bau started on 11 November, and the first one to merge two days after that. That one was small: one requirement and four short builder rounds, two of them fixes from the review.
| 13 November: one requirement | 15 November: four requirements | |
|---|---|---|
| stop reason | done: merged after I approved it (back then, gate two was the merge itself). |
checks-red: three requirements built, three resumes, then one flaky test in the product's CI. I merged its work by hand two days later, with one test of mine added: the existing ones didn't catch a deliberately broken line. |
| wall time | 101 minutes, plan to merge | 597 minutes |
| rounds | 13: planner 1, test writer 1, builder 4, blame 4, reviewer 3 | 46: planner 1, test writer 9, builder 13, fixer 2, blame 14, reviewer 7 |
| time while working same minute scale | 88 minchecks 73 min agents 15 minThe rest: 13 minutes at the two gates (gate one under a minute, approved for me by a Claude session; gate two 12 minutes, by me). | 397 minchecks 319 min agents 78 minThe rest: 177 minutes queued behind the other run of that day, 17 minutes waiting for me, and about 6 minutes of the foreman's own steps (rooms, pull request). |
| cost | $5.19 at API prices | $19.40 at API prices |
What surprised me most: the agents were the fast part and the checks the slow one. That was partly my own design, since every feature check ran the product's whole unit suite.
Foundry's runs on Bau, November 2026
| Build runs started | 15, from 11 to 19 November |
|---|---|
| Runs merged | 9. Two merged themselves (all checks green and no open review point, the rule is code). I approved two myself, one at a terminal and one through my answer to a judge question. A Claude session approved the other five, under a standing go-ahead from me. |
| Runs stopped | 6: four by me (their branches predated fixes to the test setup), two on red checks |
| Resumes by hand | 22 in all, none in the last three runs |
| Requirements on main | 14: twelve through their run's own merge, two through my hand merge of a stopped run's pull request |
| Requirements set aside | 2, in one run, so the rest could merge. I narrowed their text, and the next run built them. |
| Tasks | 119 reached a verdict: 94 green after the builder's round, 14 after one fixer round, 11 blocked |
| Judge calls | 9: four decisions, four facts, one question for me. I haven't overturned or confirmed any yet. |
| Fixes after a merge | Not tracked yet. I know of none from the first week on one product. |
| Cost at API prices | About $220 for all 15, and $5.19 to $38.70 per merged run. That's a floor: a round that hit its turn limit and failed recorded no cost. |
| Discovery runs | 8, from 6 to 19 November: recorded customer calls and documents in, claims, questions and draft requirements out, $2.46 to about $250 each at API prices. They run on foundry's runner scripts, not under the foreman. |
What the runs showed
- The run series of 13 and 14 November took 32 hours, and about 5% of that was real work. Since then the acceptance tests run first. The whole suite runs at the goal check and in a background job of its own, plus in a task check only when a touched file is outside every mapped folder, and no longer in every feature check. Where the rest went
- What I can't show yet: that splitting the roles beats one strong agent session. I haven't run that comparison. More in Limits.
What went wrong
-
Requirements as islands
Bau's guarantee protocol was specified from interviews, and the customer signed it off. Once built, each requirement was its own island, a page and a button, and the full workflow didn't work end to end. I rewrote it around how his inspections actually go, and it held up at the inspection above. I'd been tuning prompts and models. The gap was what nobody had written down about how he works.
-
Runs that stopped on small things
Early runs stopped on a gap in a requirement, a port in use, a flaky test. Of the early runs that got to the end, all three stopped on a question for me, and each came with a recommendation I simply took. So foundry got a judge, which now answers those questions itself, and an overseer for a run that stalls. The overseer only picks from a fixed list of moves that code checks, because a free agent in that seat could have weakened a check to get past it.
-
The review came last
That one was my call. I put the run's code review after the full suite and CI, so every review fix paid for the whole suite again. Now the review comes before them.
How one run goes
A run takes a batch of approved requirements. A plain program, the foreman, gives each job to a fresh agent session (a round) and checks what comes back. It writes no code itself. Each run gets a throwaway virtual machine on my own homelab, destroyed when the run ends. When a round finds a gap in a requirement, a judge round fills it with the option that's easiest to undo, or asks me.
-
Plan
A planner splits the batch into features and tasks.
-
Gate one: the plan is approved
By me, or by a Claude session under my go-ahead, and tied to a hash of the plan's text.
-
Test first
A test writer writes acceptance tests that fail before anything is built, or says why one is already met.
-
Build, then check
A builder takes one task, the foreman runs its tests, green freezes it, red goes to a fixer.
-
Feature check
On a red acceptance test, blame reopens only the task at fault, then a reviewer reads the feature.
-
Goal check
A reviewer reads the whole run, then the full suite and the product's CI run.
-
Gate two: I approve the release
A clean run has merged itself and reached dev; I read its report and decide on production.
Read the role sheets: builder, test writer, judge. The full design: checks, guards, what each round gets, and how a run ends.
Where I decide
Foundry has three loops, and each stops for me. Discovery turns recorded customer conversations into draft requirements (the eight discovery runs above), and I approve each one. Build is the run above, with its two gates; on Bau a Claude session approved every plan and five of the merges under my go-ahead (what that means). In UAT, personas use the whole app before a release, and a normal release waits for their report (a soft block, hotfixes exempt).
My co-founder records the customer calls. The loops themselves are my own work. The three loops, the judge and the overseer, in full
Laneboard
Laneboard is where I watch foundry: the runs, the gates and every Claude Code session in lanes, with an inbox of things waiting on me. Loop runs built it too.
A plan waiting at gate one. Laneboard calls a plan a recipe.
Work with me
I'm open to forward-deployed and applied-AI roles. Foundry is my own project, and Navigo's products use it.
If you're hiring for that, or you'd like to try a run on your own product, write to me on LinkedIn.
If you bring a product
It needs a GitHub repository, tests, CI and a profile with its install, build and test commands. Every real build run has been on one product, one stack and one model provider: Python (FastAPI) and TypeScript (Next.js) on PostgreSQL, with Claude. You'd still approve the requirements, each plan and each release yourself.