Three coding agents, one workspace

I started pvc-builder as a pricing experiment. I had just built Riglab with Claude Fable, which was freakishly capable and cost a small fortune. The companion tool seemed like a fair test for Opus: same problem area, same quality bar, and less autonomy. I would do the planning Fable normally burned tokens doing for me.

It worked. Opus took pvc-builder from an empty scaffold to a deployed 3D editor in under 24 hours and about 35 commits. It cost many hundreds of dollars less than Riglab. I had a tidy conclusion ready: Fable charges an autonomy tax, while Opus keeps up if I write a good plan.

Then Anthropic reset my Fable limit after GPT-5.6 came out. I put Fable back on the project, Codex joined in, and the clean experiment died immediately. That turned out to be more useful. Instead of answering which model was best, pvc-builder showed me how several strong agents can improve the same project when the repository tells them how to cooperate.

Opus built the map first

The original Opus pass didn’t begin with app code. I gave it a wall of text about the product, constraints, the parts of Riglab worth stealing, and what I didn’t want. It turned that into the files that still organize the project:

• a plan with the product, non-goals, model, phases, and acceptance criteria;
• a code map and short CONTEXT.md file in every source directory;
• a newest-first decision log;
• clean boundaries around fitting resolution, the bill of materials, and the solver;
• one editor action layer shared by pointer controls and automation; and
• a window.__pvc hook that lets scripts inspect and operate the running app.

That sounds like a lot of paperwork for a two-day toy. It is why the toy survived 126 commits in two days.

The context cards do more work than I expected. An agent changing fitting geometry can learn the exports, dependencies, and rules without swallowing the whole repo. The decision log keeps the next session from reopening a solver argument I already paid for. Clean boundaries keep three.js objects out of the cut-list math.

Opus had 104 credited commits at the time. It built the app and the surface that made handing the app to another model reasonably safe.

Codex reviewed the thing that existed

Once the first version worked, I gave Codex the repository and running app. It didn’t need the original chat. The plan, cards, decisions, tests, and automation hook were already there.

Its review was broad and unsentimental: organize the editor around Design, Fabricate, and Simulate; show the assumptions behind the bill of materials; add real project recovery; expose joint state; split the giant shell; add interaction tests; and fix docs that no longer matched the code. The implementation touched 43 files, added about 3,500 lines, and removed about 750. Without the map and tests, that would have been a hell of a mess. Here it was one reviewable branch.

The useful part wasn’t that Codex had different taste. It was that a second model looked at a working tool without caring how the first model got there. Opus optimized for getting it built. Codex treated the rough edges as an architecture problem.

The repo also had a coordination board: claim files, use a worktree, avoid shared choke points, run the full test suite, merge, and release the claim. Schema migrations, the editor shell, central actions, scene composition, and main document operations were called out by name. Work in separate directories could run in parallel. Those files had to take turns.

Fable went after the seams

After the Codex branch landed, Fable handled a string of passes from v0.3.1 through v0.3.13. It cleaned up the desktop workspace, made the editor usable on phones, consolidated panels, added a Blender-style cavity render, packed cut lengths into stock, fixed selection under camera drift, added typed rotation, and kept finding interaction bugs I never would have described in a plan.

Then it got into the geometry. A red pipe crossing became a Solve action that clusters intersections before splitting anything, creates one junction, and represents the fabrication honestly. The next pass turned weird corners into heat bends and many-way junctions into fabricated hubs. Another fixed the bend radius because the mathematically valid result looked nothing like PVC I could heat and fold.

That sequence is why fresh passes work. The first implementation makes the problem visible. The next agent finds the missing case. The one after that notices the solution is technically valid and physically stupid. Each inherits the tests, decisions, context cards, and an app it can inspect through the same hook.

Fable had 14 credited commits in that snapshot. GPT-5.6 was working through another pass, but its changes weren’t committed yet, so I didn’t count them. Git can record what changed. Model attribution is only as good as the commit message.

The old cost problem didn’t disappear. I burned 36 percent of the newly reset allowance in about three hours. Fable was excellent at this work and still consumed its budget like it had a personal grievance against the meter.

The workspace is the conversation

The common picture of a coding agent is one model in one chat, slowly filling its context until details start falling out. This felt different. The durable conversation was the repository:

• The plan said what I was building.
• Decisions explained the current shape.
• Context cards said where everything lived.
• The board said who could touch what.
• Tests said which claims had to remain true.
• The browser bridge showed what the app was doing.
• Git recorded what each pass changed.

The models didn’t need a shared hidden train of thought or a giant transcript. They needed an inspectable workspace and rules for changing it.

Their differences became useful. Opus could grind through a structured plan without setting the budget on fire. Codex was good at reading the whole system and proposing a cleaner shape. Fable explored aggressively and was excellent at the “keep going until it feels right” work. I remained the scheduler, product owner, QA department, and guy with increasingly specific opinions about hot PVC.

It stopped being a benchmark

The original comparison was already unfair. pvc-builder learned from Riglab, reused its stack, and benefited from my first round of mistakes. Once three agents took turns, the pricing experiment was completely shot.

That result was more interesting than “model A beat model B.” In a little over two days, the repo went from a scaffold to a deployed v0.3.13 app with 126 commits, fabrication tools, rigid-body simulation, a responsive editor, browser automation, and enough PVC geometry to model the creature I plan to build.

The agents didn’t agree their way there. They found different problems at different times. The repository kept the decisions still long enough for the next one to make the project better.