Case Study: Building a Scene
One scene, two agents, zero work from the dev in the editor. The Never House is a CRT wireframe horror game built with Godot Runtime Bridge and Aesthetic Engine Builder — the studio’s own flagship example. This is an unedited walkthrough of how its dining room was redesigned — Codex diagnosing the problem live against the running game, Claude doing the art direction, and Codex implementing the result back into the runtime and adding finishing touches directed by the user. Every screenshot below is a real step from that session, in order.
Before
Section titled “Before”The dining room existed and ran cleanly, but it was visually flat next to the rest of the house — a center-box table on broad horizontal bands, no depth cues, nothing that read as “dining room” instead of “room with a rectangle in it.”
The starting point. A flat dining room render with no perspective floor, no focal silhouette, and no story embedded in the geometry — just a table in a box.
Diagnose — Codex + GRB
Section titled “Diagnose — Codex + GRB”The session starts inside Codex, connected to the live, running game through the Godot Runtime Bridge. No editor, no manual screenshotting — Codex launches the game itself, navigates to the room, and captures what’s actually on screen.
The brief: “I need to improve the visuals in the dining room, they aren’t up to par with the exterior, foyer, or living room.” Codex is asked to capture the current state and propose directions — not yet to make changes.
After working directly against the running build for a couple minutes, Codex returns five concrete directions — a perspective floor, an implied “dinner that never arrived,” a stronger focal silhouette, less generic geometry, and a frame-1 escalation — along with confirmation that GRB launched the game cleanly and captured the room from the live runtime, with no errors surviving past an initial bad eval call.
Design — Claude
Section titled “Design — Claude”Codex’s diagnosis gets handed to Claude, alongside the room screenshot, for art direction. This is a separate conversation in a separate tool — the kind of cross-agent handoff GRB is built to support, since the runtime state and visual evidence travel with the screenshots rather than staying locked inside one session.
Codex’s five suggestions, pasted in full alongside the room screenshot, with a simple question: what’s the best way to actually design this space?
Rather than treating all five suggestions as equal, Claude ranks them — leading with the chandelier as “the room’s soul,” the perspective floor as the most urgent functional fix, and frame 1 as the most underrated opportunity for escalation.
A full concept mockup, rendered as SVG, showing both states side by side — Frame 0 at rest and Frame 1 after the chair is touched — with each design decision numbered against the original five suggestions.
Claude walks through the reasoning — the chandelier’s pivot point, the missing plate’s implied narrative, the gothic chair arch — then gets redirected: lose the face in the window, and the shape on the right should read as a door to the living room.
A floor-plan correction: kitchen door on the left, living room door on the right, which means the window has to move to the exterior left wall. Claude reworks both far-wall elements as matching gothic arched doors and relocates the window accordingly.
The updated render: both far-wall elements are now arched doors, the window sits correctly on the left wall, and the candlesticks have moved to a small console between the two doors.
Claude flags what’s left to fix — the window’s foreshortening and a completely bare right wall — and gets three more notes back: move the door handle, fix the window angle, and strip the numbered callouts.
A cleaner pass: door handle repositioned, window geometry corrected to a gentler, more legible tilt, and the annotation layer removed entirely — this is starting to look like a final reference image.
One last round of chair fixes — orientation, scale, dropping two extra chairs and the window entirely — and Claude exports the result as a flat reference image: Dining room v4.
Implement — Codex + GRB
Section titled “Implement — Codex + GRB”The concept image goes straight back into the original Codex session. From here it’s a verification loop: edit the procedural drawing code, launch the game through GRB, screenshot the result, compare, fix, repeat.
Back in the GRB session, Claude’s concept gets pasted in with a single instruction: “can you make the dining room match this concept.” Codex goes to work directly on the procedural drawing code.
First pass: boxed perspective, twin arched cabinets, a sideboard with candles, a larger chandelier, place settings, high-backed chairs, and a stronger frame-1 disturbance — captured live and verified with zero runtime errors.
A depth artifact: the far-wall cabinet and door panels were bleeding past the wall/floor line. Codex corrects the constraint and strips the leftover perspective guide lines while it’s in there.
Two more readability notes in one round: the back cabinet still wasn’t masking the floor line behind it, and a back chair was cluttering the silhouette. Both fixed in a single pass.
Pixel-level QA: a markup directly on the screenshot calling out a visible floor line, a diagonal chair leg, diagonal table legs, and a chair leg not attached to its seat. All four fixed in one targeted edit.
A catch on the way out: removing the leftover perspective guide lines had accidentally taken the side room walls with them. One more fix restores the walls while keeping the guide lines gone.
The dining room as it actually runs. Composure meter, inventory, and narrative text all live — captured straight from the running build, the same way every step in this session was: through GRB, against the real game, not a mockup.
Why This Workflow Works
Section titled “Why This Workflow Works”No single agent did this alone, and that’s the point. Codex never had to guess at art direction — it diagnosed the problem against the live runtime, then implemented a concept it didn’t have to invent. Claude never had to touch a Godot project or guess what was actually on screen — every decision was grounded in a real screenshot. And because GRB keeps the loop closed — launch, observe, edit, verify — every claim of “fixed” in this session was checked against the running game before it was reported, not assumed.
The whole exchange, start to finish, lived in chat windows and a running game. No manual screenshotting, no Alt-Tabbing to the editor, no “looks right to me” without proof.