Resurrecting the 1990s Web: Building a VRML Parser in 9 Days with Kiro

How AI-assisted development and 20 years of VR expertise brought dead 3D web standards back to life

The Problem: Digital Archaeology

While cleaning out some old university archives recently, I stumbled upon something fascinating: thousands of .wrl files from the 1990s—virtual art galleries, 3D molecular models, early game prototypes—all completely inaccessible in modern browsers.

VRML (Virtual Reality Modeling Language) was the web's first attempt at 3D content, predating WebGL by over a decade. It died spectacularly when browser plugins fell out of favor, leaving an entire generation of 3D creativity frozen in digital amber.

As someone who spent 20+ years in VR/AR at Meta, I couldn't let that stand. But there was one problem: I'd been in program management for years, not writing production code.

Enter Kiro.

Why VRML is Terrifyingly Complex

VRML isn't just "old"—it's aggressively 1990s. The syntax has quirks that would make a modern parser cry:

# Yes, comments start with # like Python
Transform {
  translation 0.5 1.0 0.5  # NOT a JSON array!
  rotation 0 1 0 1.5708    # Axis-angle, NOT Euler angles
  children [
    Shape {
      appearance Appearance {
        material Material {
          transparency 0.5  # 0=opaque (INVERTED from CSS!)
        }
      }
      geometry Box { size 1 1 1 }  # Optional commas everywhere
    }
  ]
}

Modern parsers assume JSON-like syntax. VRML assumes you're writing in 1997 and have all the time in the world.

The Kiro Advantage: Teaching an AI About the Past

Here's where things got interesting. Instead of fighting with Kiro to understand VRML, I taught it using steering documents.

I created .kiro/steering/project-context.md with critical context:

## VRML Syntax Quirks
- Uses SFVec3f notation: `0.5 1.0 0.5` (NOT JSON arrays)
- Rotations in axis-angle format (x, y, z, angle)
- Transparency is 0=opaque, 1=fully transparent (INVERTED from CSS)

That last line? Saved me 6 hours of debugging.

Without steering, every conversation about transparency started with Kiro generating CSS-style opacity code (0=transparent). With steering, it immediately understood VRML's inverted semantics.

Small investment. Massive ROI.

Spec-Driven Development for Complex Parsers

For the core parser logic, I used spec-driven development—writing detailed specifications before any code.

.kiro/specs/vrml-parser.md broke VRML into digestible chunks:

• Phase 1: Lexer (tokenization, comments)
• Phase 2: Basic nodes (shapes, materials, transforms)
• Phase 3: Advanced geometry (IndexedFaceSet meshes)
• Phase 4: Materials & effects (transparency, emissive colors)

The IndexedFaceSet parser was the test case. These nodes define real 3D meshes using flat coordinate arrays with -1 separators:

geometry IndexedFaceSet {
  coord Coordinate {
    point [ 0 0 0, 1 0 0, 1 1 0, 0 1 0 ]
  }
  coordIndex [ 0, 1, 2, -1, 0, 2, 3, -1 ]  # -1 = face boundary
}

Converting this to Three.js BufferGeometry while calculating face normals? That's a ~150-line function that needs to work perfectly.

With vibe coding alone: 3-4 debugging iterations

With spec-driven development: Worked on first try

The Hybrid Approach: When to Spec, When to Vibe

Nine days in, I learned which tool fit which job:

Specs won for:

• Complex data structures with edge cases
• Parser logic (deterministic rules)
• Anything that needed to work perfectly first time

Vibe coding won for:

• UI components (subjective design)
• Quick bug fixes ("the rotations are inverted, flip the sign")
• Creative content (the Halloween graveyard demo scene)

The key insight: Use both strategically. Don't force specs on subjective design. Don't iterate through vibe coding on complex logic.

Agent Hooks: The Secret Weapon

The real productivity unlock? Agent hooks.

I created .kiro/hooks/test-scene.sh that automated:

1. VRML syntax validation
2. Parser execution on all test files
3. A-Frame output generation
4. Auto-opening results in browser

Before hooks: 3-minute iteration cycle

After hooks: 15-second iteration cycle

Over 9 days, this saved ~10 hours of manual testing. That's 10 hours I spent adding features instead of clicking buttons.

The deployment hook was even better—it caught that I'd accidentally added .kiro to .gitignore, which would've been instant disqualification from the hackathon.

Hooks literally saved my submission.

The VR Background Advantage

Here's the thing most developers won't tell you about AI-assisted development: domain expertise is the multiplier.

My 20 years in VR meant I could describe problems precisely:

❌ "The 3D models aren't rendering right"

✅ "IndexedFaceSet coordinate arrays with -1 face separators need conversion to Three.js BufferGeometry with proper normal calculation"

That specificity eliminated trial-and-error iterations. Kiro isn't replacing expertise—it's amplifying it.

Most Kiroween participants are full-stack web developers. I'm the only one with serious spatial computing experience. That differentiation matters when judges evaluate 3,000+ submissions.

What I'd Do Differently

I should have used MCP. I explored Model Context Protocol for 3D validation but didn't implement due to time constraints. In retrospect, integrating external VRML validation tools would've caught edge cases earlier.

I should have recorded more. Kiro's most impressive moments (generating the IndexedFaceSet converter perfectly on first try) weren't screenshotted. Document everything—you'll want it for writeups.

I should have started the demo scene earlier. The Halloween graveyard with 35 glowing jack-o'-lanterns and transparent ghosts was built on day 8. Starting earlier would've given more iteration time.

The Result: Production-Grade in 9 Days

VRML Reborn now parses:

• 8 major node types (Shape, Transform, Material, etc.)
• Complex IndexedFaceSet meshes (real 3D geometry)
• Advanced materials (transparency, emissive colors)
• Nested transforms and DEF/USE references
• WebXR with one-click VR mode

Try it: [your-vercel-url-here]

Upload any .wrl file and watch a piece of 1990s web history come back to life.

The Real Lesson: AI + Expertise = Magic

Kiro didn't write this project. I didn't write this project. We built it together.

The combination of:

• Steering docs (teaching Kiro about 1990s quirks)
• Specs (handling complex logic deterministically)
• Vibe coding (rapid UI iteration)
• Hooks (automation that saved hours)
• Domain expertise (20 years of spatial computing)

...created something neither of us could have built alone.

That's the future of development: not AI replacing developers, but AI amplifying what makes each developer unique.

Now if you'll excuse me, I have 500 more vintage VRML files to resurrect.