Same prompt, two engineers:
Fable and Opus build the same DOOM

Both got the identical brief — a mobile-portrait DOOM-style raycaster, gpt-image-2 wall panels + enemies, "make it look good." Both wrote a from-scratch software raycaster in TypeScript, no engine. Clean rooms, zero shared code. Then we went part by part through what each one chose. The same fork shows up at every layer.

what you actually see

part 1 — floors & ceilings

Fable wins. Opus didn't skip floors — it drew them the cheap way, as two flat gradients, so the ground reads as a featureless dark void. Fable cast a real textured, perspective-correct floor.

// per screen row, project the world-space
// ground point and sample a floor texture
for (let y = 0; y < VIEW_H; y++) {
  const isFloor = y > horizon;
  const rowDist = halfH / (isFloor ? y-horizon : horizon-y);
  const shade = this.fog(rowDist) * (isFloor?1:0.62);
  // ...sample floorTex per pixel across the row
}

this.ceil  = ctx.createLinearGradient(0,0,0,half);
this.ceil.addColorStop(0, `rgb(${CEIL_RGB})`);
this.ceil.addColorStop(1, `rgb(${FOG})`);
this.floor = ctx.createLinearGradient(0,half,0,H);
// ...filled as 2 solid bands. no texture, no perspective.

part 2 — wall texturing

Fable wins on sharpness. Both run the identical ray math. The split is the final draw: Fable writes texels by hand into a pixel buffer (crisp). Opus slices a 1px column and lets the browser stretch it (soft/blurry).

for (let y = y0; y < y1; y++) {
  const px = tpx[ty*tw + texX];      // nearest texel
  let r=(px&255)*shade, g=..., b=...;  // fog × pixel
  u32[y*VIEW_W + x] = 0xff000000|(b<<16)|(g<<8)|r;
}

ctx.drawImage(tex, texX,0,1,tex.height, x,start,1,lineH);
// browser bilinear-stretches the 1px column
// vertically → soft, slightly blurred walls

part 3 — fog & distance

Fable wins. Fable folds fog into the pixel's own color — true darkening that keeps contrast. Opus paints a semi-transparent fog-colored rectangle on top, which uniformly washes distant detail toward flat black. That overlay is exactly the "muddy" look.

let shade = this.fog(perpDist) * boost
           * jitter[cell] * zoneLight[cell];  // + light zones
r = texel_r * shade;  // darkens the real color

const fog = Math.exp(-dist * FOG_DENSITY);
ctx.fillStyle = `rgba(${FOG},${1-b})`;
ctx.fillRect(x, start, 1, lineH);  // veil over the wall

part 4 — lighting

Fable wins. Fable gives each cell its own animated light zone — broken-ballast flicker, hell-pulse, dim — updated every frame. Opus uses one global light scalar times a static per-cell hash. One breathes; one is uniform.

private zoneLight: Float32Array;  // one per cell
// each frame: pulse / flicker / dim modes + muzzle boost
if (z.mode==='flicker') /* harsh broken-ballast */
if (z.mode==='pulse')   /* slow hell breathing */

function cellBright(x,y){ /* static hash jitter */ }
let b = fog * sideShade * cellBright(mx,my) * light;
// `light` is a single number for the whole scene

part 5 — doors

Fable wins. Fable modeled real Wolf3D-style sliding doors right inside the ray loop — the ray hits the door plane at the cell midline and slides it into the jamb. Opus's loop has no door case at all: every solid cell is just a wall.

if (cell===DOOR) {
  const dMid = side===0 ? sideX-deltaX*.5 : sideY-deltaY*.5;
  let u = hitCoord - Math.floor(hitCoord);
  u -= open;             // door slides into the jamb
  if (u >= 0) { tex = door; break; }
}

if (tile > 0) break;  // every solid cell = a plain wall.
// no midline, no slide, no door texture branch.

part 6 — the enemy fused to the gun

Opus shipped IRONMAW with a demon glued on top of the gun. Its QA never caught it — and here's the twist: it wasn't a code bug at all. The fix came only when Opus was told to record combat video and read the frames.

part 7 — how each tested itself

Fable wins — and this is the deepest split. Both had ffmpeg + Playwright sitting right there. Fable reached for video; Opus reached for assertions.

// 8 self-play bot runs · 5 ffmpeg calls · video frames
"Timing luck is against me — let me record a
 video instead and pull frames with ffmpeg."
// → looks at combat IN MOTION

// e2e: "shoot → enemy drops, no console errors"
expect(__game.enemies).toBeLessThan(before);  // ✅
// verifies combat WORKS, never that it LOOKS right

the pattern

the fusion experiment — can two blind Opus beat one?

The page above ends on a wall: create is intrinsic. So we tested the most-hyped way around it. OpenRouter just shipped "Fusion" (Fable-tier answers from cheaper models); an open-source clone runs two Opus 4.8 on the same task, blind to each other, then a third Opus reads both and writes the final — "one run can be confidently wrong; two, cross-examined, can't hide it." We ran exactly that on the Opus DOOM: two blind builders each pushed the same v2 toward HULLROT with video QA, then an Opus judge fused them into v3. Clean rooms, a blindness watchdog, every score checked against the reference by eye.

part 8 — the five frames, side by side

Same corridor, same vantage. Watch the floor tone and the walls as you read left to right — the two blind builds each fixed a different thing and broke a different thing.

part 9 — where fusion earned its keep

Fusion genuinely beat both single runs — for the precise reason the trick predicts. The two blind builders converged where it mattered and diverged where it counted.

part 10 — what fusion could NOT do

Now look at v3 against HULLROT again. v3 is the cleanest Opus frame — but it's still not in the same room as Fable, and the reason is the whole point.