←Back/Product/Claude
AdvancedProduct

Build an Interactive 3D Application Using a Reference Project

Create a novel, interactive 3D application, like a functional typewriter, by providing Fable 5.2 with a high-quality open-source project as a reference and a clear creative concept. This workflow focuses on getting a core mechanic working first, then iterating on features.

Illustration for Build an Interactive 3D Application Using a Reference Project

I was mega, mega, mega inspired by this and pointed Fable 5.2 at a similar but different problem. And I would like to introduce you to Claire's typewriter. So this is a fully functioning 3D rendered typewriter... You can type on it by clicking the keys or you can type on it by using your keyboard.

Before you start

What you need

  • A URL to a high-quality, open-source reference project (e.g., a 3D viewer, a simple game).
  • A clear concept for a new, related interactive application.

What you’ll make

Working code for an interactive 3D scene where the core user interaction is functional.

Tools used

The workflow

Follow the sequence once, then adapt the prompts, checks, and handoffs to your own setup.

5 steps

Step 01

Find a High-Quality Reference

Find an open-source project that has a technical or aesthetic quality you want to emulate. The source used Guillermo Rauch's 3D record player as inspiration for its rendering quality.

The reference project acts as a concrete anchor for the model's creative and technical direction. A link to a GitHub repository is ideal.

Step 02

Define a New, Related Concept

Formulate a clear idea for a new application that is related to but distinct from the reference. The source example is pivoting from a '3D record player' to a 'functioning 3D typewriter'.

A clear, concise concept helps the model understand the goal. 'Functioning' is a key word that implies interactivity.

Step 03

Write the Initial Prompt

In a coding environment like Claude Code, prompt Fable 5.2 with both your reference and your new concept, asking it to build the core of the application.

Example prompt
I was inspired by this 3D record player project: [link to project]. Using a similar aesthetic and technical approach, build me a functioning 3D typewriter that responds to my computer's keyboard input.

Be specific about the core interaction you want to work 'out of the box'. The source notes the keyboard functionality was the 'one-shot' result.

Step 04

Test the Core Interaction

The model will generate the initial code. Immediately run and test it to verify that the primary mechanic works. For the typewriter, this meant checking if keyboard input appeared on the virtual page.

Do not proceed to adding features until the core is solid. This is the most important human checkpoint in the process.

Step 05

Iterate by Adding Features

Once the core is working, ask for new features one at a time. The source added rain, timers, music, and different scenes iteratively.

Example prompt
This is working great. Now, add a button that toggles a rain effect in the scene.

Adding features one at a time can make it easier to isolate a regression, though the cause still needs checking.

What good looks like

  • The core interaction of the application is functional (e.g., keyboard input appears on the 3D typewriter).
  • The application is interactive, not just a static 3D render.
  • The aesthetic is inspired by the reference project but applied to the new concept.

Build your next product with ChatPRD

Turn an idea into a PRD, user stories, and a plan.

Try ChatPRD free

Runbook notes

How to recover when the loop fails and where human judgment helps.

If it goes sideways

The model generates a non-functional or broken feature, like the 'correction feature' that didn't work correctly in the source.
Isolate the code for the broken feature. Describe the incorrect behavior and the expected behavior to the model, and ask it to debug that specific function.
The model produces a static 3D render instead of an interactive application.
Re-prompt with a focus on the interactive element. Example: 'This render is beautiful, but it needs to be interactive. Please write the JavaScript to make the keys respond to keyboard input.'

Human checkpoints

Let routine work keep moving.

  1. Run the initial code to test that the core interaction is functional before requesting additional features.
  2. Test each new feature individually as it's added to identify what works and what needs debugging.

Start shipping better products.

Join 250,000+ product managers who use ChatPRD to write better docs, align teams faster, and build products users love.

Free to start · 14-day Pro trial · SOC 2 Type II