I must start by saying: AI is indeed powerful for writing 3D code.

So powerful that it's unsettling.

In the past, I would spend three days reading documentation and testing seven or eight different approaches to build a model interaction pipeline. Now, AI spits it out in seconds. GLTF loading, PBR materials, post-processing effects, and even optimization details I hadn't considered—it all gets filled in automatically.

For instance, I asked AI to write a simple model loading code. Honestly, even if I wrote it by hand, it would be at about this level:

// AI-generated Three.js model loading – runs perfectly in standard environments
import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';

const loader = new GLTFLoader();
loader.load(
  '/assets/model.glb',
  (gltf) => {
    scene.add(gltf.scene);
    console.log('Model loaded successfully');
  },
  (progress) => {
    console.log(`Loading progress: ${(progress.loaded / progress.total * 100).toFixed(2)}%`);
  },
  (error) => {
    console.error('Model loading failed:', error);
  }
);

Looks fine, right? Loading progress callback, error handling—all there.

At that moment, honestly, a chill went down my spine. Six years of experience suddenly felt devalued in front of this.

But I have this habit: after the panic, I start looking for its flaws.

So for the past six months, I've been doing one thing: intentionally throwing AI-generated Three.js code into "hellish environments."

What is a hellish environment? Not your MacBook, not the latest Chrome. It's the industrial PC at a client's site—embedded Windows 7, Chromium 49 kernel, integrated GPU, offline network, and security software silently deleting things in the background.

AI's code dies horribly there.

First Crash Scene: Offline Intranet Environment, All Textures White

The AI-generated loader uses the path /assets/model.glb, which embeds textures with relative paths. Works fine locally. But when deployed to the client's intranet server—disconnected from the internet and without external DNS—everything turns white.

The console shows no errors. GLTFLoader fails silently, not even triggering the error callback. AI has no idea that in some intranet environments, even blob: protocols are blocked by security policies.

I ended up fixing it like this:

// Fix: intranet offline environment adaptation
import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';

const loader = new GLTFLoader();
// Key: set cross-origin policy, take over texture loading
loader.setCrossOrigin('anonymous');
// Key: disable external resource requests, force all textures to be base64 embedded
loader.setResourcePath('');

// Pre-check: whether the current environment supports blob protocol
const isBlobSupported = (() => {
  try {
    const testBlob = new Blob(['test'], { type: 'text/plain' });
    URL.createObjectURL(testBlob);
    return true;
  } catch (e) {
    return false;
  }
})();

if (!isBlobSupported) {
  console.warn('Current environment does not support Blob protocol, textures will fallback to solid colors');
  // Proceed with fallback rendering branch
}

AI wouldn't write this. It has never seen an environment where even Blob fails to run.

Second Crash Scene: Older Browser Loses GPU Context Mid-Run

AI's standard render loop is clean and efficient:

// AI-generated standard render loop
function animate() {
  requestAnimationFrame(animate);
  renderer.render(scene, camera);
  stats.update();
}
animate();

On the latest Chrome, it's rock solid.

But on that domestic dual-core browser's "speed mode," it runs for less than five seconds before the entire canvas goes black. The console throws something AI never handled:

WebGL: CONTEXT_LOST_WEBGL

Then the page freezes, completely unresponsive. Refreshing doesn't help because the browser already suspended the GPU process.

AI's code has zero defense against this.

Here's the fix I added:

// Fix: GPU context loss protection for older browsers
function animate() {
  requestAnimationFrame(animate);
  
  try {
    renderer.render(scene, camera);
  } catch (e) {
    // Catch render exceptions to avoid crashing the entire loop
    console.warn('Render frame failed, skipping current frame:', e.message);
    return;
  }
}

// Core: handle context loss event
renderer.domElement.addEventListener('webglcontextlost', (event) => {
  // Prevent default behavior to gain recovery time
  event.preventDefault();
  console.warn('WebGL context lost, attempting recovery in 2 seconds...');
  
  // Pause rendering, free some GPU memory
  cancelAnimationFrame(animationId);
  
  // Attempt context recovery
  setTimeout(() => {
    renderer.domElement.addEventListener('webglcontextrestored', () => {
      console.log('Context restored, restarting render loop');
      animate();
    }, { once: true });
  }, 2000);
}, false);

// Extra safety: detect if browser is domestic dual-core
const isOldBrowser = /360|LieBao|MetaSr/.test(navigator.userAgent);
if (isOldBrowser) {
  // Lower pixel ratio to reduce GPU memory pressure
  renderer.setPixelRatio(Math.min(window.devicePixelRatio, 1));
  // Disable GPU-heavy features like shadows and post-processing
  renderer.shadowMap.enabled = false;
}

After adding this code, that old machine ran for an entire afternoon without crashing again.

I stared at the crash logs and suddenly smiled.

Not mocking AI, but relieved.

It turns out that AI is powerful, but it has never seen the real world. Its training data consists entirely of ideal environments—standard browsers, latest APIs, perfect networks, latest drivers. In real industrial settings, these are illusions.

It's not a god. It's a top student raised in a perfect anvironment, who has never stepped in muddy puddles.

And how many such muddy puddles exist in China? Domestic dual-core browsers, intranet security policy blocks, aging hardware that must keep running, antivirus software treating WebGL as a virus... AI can't solve a single line of this.

Not that it won't ever solve it, but right now, it really can't.

Realizing this, my anxiety faded. Not because I am smarter than AI, but because I figured out what I need to do next:

AI is responsible for generating beautiful demos in perfect environments. I am responsible for making it run in real hell.

It gives me cost reduction and efficiency; I clean up its mess. It acts as the brain; I am the one who knows how to walk through mud.

Technical barriers have indeed been broken down. But new barriers have been erected right at the moment when AI-written code "dies at the client site."

So now, I embrace AI and use it every day. But every day, I find in its output the very reason for my existence.

I went through anxiety, but now I am clear-headed.

If you also feel that your skills are being replaced, don't look at what AI excels at. Go and run its code on your worst device.

The answer is in that error log.