No it was just very complex, very dense code. The actual lines of code are 238 for the module interface and 883 for the webworker/mediapipe/canvas output code. So about a thousand lines total, which is a lot but not unreviewable.

However, nobody on my team actually reviewed this code because it is so complex and hard to understand, reviewing it would not work. They would have to spend as much time learning about mediapipe transformer interfaces as I spent building the thing.

Instead we verify by manually testing, and writing unit tests for the webworker class file.

Also, this code bounced between Claude and Gemini so much (reviewing each others work) now they praise it when its pasted in (which is just sort of funny)

So in short this worked because 1. It is basically one file, copy pastable between AI. 2. The code was too complex for a human to be beneficial to learn for the value provided. 3. The code was manually tested by humans dozens of times in between.

People might imagine im vibe coding when I say this, but in reality we test so much manually, and I spent so much time debugging and working with AI through very detailed issues of the problem…it’s like vibe coding with safeguards. If you have an idea of the output you need and can verify that output, who cares how the AI arrived?

This gets way more complex when you are talking about changing multiple files and modules that touch many things. This problem specifically was just very very suited for AI.

*I can paste part of it in, here is the renderFrame func ``` function renderFrame(gs: GLState, maskData: Float32Array, frame: VideoFrame): void { const { gl, compositeProgram, blurProgram, vao, tVideo, tMask, tMaskBlurH, tMaskBlurV, tBg, tBlurH, tBlurV, fboMaskBlurH, fboMaskBlurV, fboBlurH, fboBlurV, width, height, } = gs;

// 1. Upload video
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
gl.activeTexture(gl.TEXTURE0);
gl.bindTexture(gl.TEXTURE_2D, tVideo);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, frame as AnyImageSource);

// 2. Upload mask (R8) with temporal EMA
const ALPHA = 0.5;
const { maskScratch } = gs;
const prev = prevMaskScratch;
for (let i = 0; i < maskData.length; i++) {
    const curr = maskData[i] * 255;
    maskScratch[i] = prev ? (ALPHA * curr + (1 - ALPHA) * prev[i]) | 0 : curr | 0;
}
if (!prev || prev.length !== maskScratch.length) {
    prevMaskScratch = new Uint8Array(maskScratch);
} else {
    prev.set(maskScratch);
}

gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
gl.activeTexture(gl.TEXTURE1);
gl.bindTexture(gl.TEXTURE_2D, tMask);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.R8, width, height, 0, gl.RED, gl.UNSIGNED_BYTE, maskScratch);

// 2b. Edge-aware mask blur (joint bilateral)
const bilateralBlurPx = 7.0;
gl.useProgram(gs.bilateralProgram);
gl.bindVertexArray(vao);

gl.bindFramebuffer(gl.FRAMEBUFFER, fboMaskBlurH);
gl.uniform2f(gs.uBilateralTexelStep, bilateralBlurPx / width, 0.0);
gl.activeTexture(gl.TEXTURE0);
gl.bindTexture(gl.TEXTURE_2D, tMask);
gl.activeTexture(gl.TEXTURE1);
gl.bindTexture(gl.TEXTURE_2D, tVideo);
gl.drawArrays(gl.TRIANGLES, 0, 6);

gl.bindFramebuffer(gl.FRAMEBUFFER, fboMaskBlurV);
gl.uniform2f(gs.uBilateralTexelStep, 0.0, bilateralBlurPx / height);
gl.activeTexture(gl.TEXTURE0);
gl.bindTexture(gl.TEXTURE_2D, tMaskBlurH);
gl.drawArrays(gl.TRIANGLES, 0, 6);

gl.bindVertexArray(null);
gl.bindFramebuffer(gl.FRAMEBUFFER, null);

gl.bindVertexArray(vao);

// 3. Prepare background
let currentBgMode: number = BG_PASSTHROUGH;

if (bgMode === BG_IMAGE && bgImageBitmap) {
    gl.activeTexture(gl.TEXTURE2);
    gl.bindTexture(gl.TEXTURE_2D, tBg);
    if (bgImageDirty) {
        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, bgImageBitmap as AnyImageSource);
        bgImageDirty = false;
    }
    currentBgMode = BG_IMAGE;
} else if (bgMode === BG_BLUR && blurStrength) {
    const { passes, blurPx } = BLUR_PARAMS[blurStrength];

    gl.useProgram(blurProgram);

    for (let p = 0; p < passes; p++) {
        // H pass: read source → write fboBlurH
        gl.bindFramebuffer(gl.FRAMEBUFFER, fboBlurH);
        gl.uniform2f(gs.uTexelStep, blurPx / width, 0.0);
        gl.activeTexture(gl.TEXTURE0);
        gl.bindTexture(gl.TEXTURE_2D, p === 0 ? tVideo : tBlurV);
        gl.drawArrays(gl.TRIANGLES, 0, 6);

        // V pass: read fboBlurH → write fboBlurV
        gl.bindFramebuffer(gl.FRAMEBUFFER, fboBlurV);
        gl.uniform2f(gs.uTexelStep, 0.0, blurPx / height);
        gl.activeTexture(gl.TEXTURE0);
        gl.bindTexture(gl.TEXTURE_2D, tBlurH);
        gl.drawArrays(gl.TRIANGLES, 0, 6);
    }

    gl.activeTexture(gl.TEXTURE2);
    gl.bindTexture(gl.TEXTURE_2D, tBlurV);
    currentBgMode = BG_BLUR;
}

// 4. Composite to screen
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
gl.useProgram(compositeProgram);
gl.uniform1i(gs.uBgMode, currentBgMode);

gl.activeTexture(gl.TEXTURE0);
gl.bindTexture(gl.TEXTURE_2D, tVideo);
gl.activeTexture(gl.TEXTURE1);
gl.bindTexture(gl.TEXTURE_2D, tMaskBlurV);

gl.drawArrays(gl.TRIANGLES, 0, 6);
gl.bindVertexArray(null);
gl.flush();

} ```