How to Prototype a 3D RPG Using Only AI Tools: Workflow, Costs and Pitfalls

Making a 3D RPG with AI only: what was built and why it matters

A Redditor has shared an ambitious “AI-only” game dev experiment: a third-person 3D RPG prototype created without writing code, driven entirely by prompts to the muranyi-3 model from Tesana AI. You can read the full thread here: Making a RPG game with AI only – here is my progress so far.

This build is 100% AI… 39 prompts… 2 days of iteration… Haven’t written a single line of code.

It’s early days. The creator stresses this is a base to build on – next up are core loops and combat. Even so, it’s a useful signal of how quickly a single person can get to a playable-looking scene with modern AI tooling.

What’s in the prototype so far

• World: a high medieval fantasy setting – mountainous open plain with a distant castle landmark.
• Player character: a hooded purple wizard.
• Third-person controller: camera decoupled from walking direction; jogging and walking in all directions with the camera behind the player.
• Process: plan in 3–4 prompts, then iterate on animations, world and UI details.

What’s not there yet: a game loop, combat mechanics and broader functionality. Those are significant pieces that will test whether an “AI-only” workflow holds up beyond a compelling walkaround demo.

Workflow: 39 prompts over two days

The author’s approach is structured and repeatable:

1. Planning prompts (3–4) to scope the core: theme, camera behaviour, movement, and feel.
2. Iterative prompts to tweak animations, world details and UI until the base feels right.

Two key starter prompts are shared:

• World: “Create the Foundation for a third-person 3D high medieval fantasy set in a mountainous open plain with a distant castle landmark.”
• Character and movement: “A hooded purple wizard with a world-class third-person player and movement system. Decoupled camera versus walking direction, with jogging and walking in all directions with the camera behind the player.”

The underlying model is muranyi-3 by Tesana AI. The game engine or runtime used was not disclosed.

Key metrics from the build

Model	muranyi-3 (Tesana AI)
Prompts	39
Token spend	$40 so far (tokens are the units models bill for processing text/code)
Development time	~2 days of iteration
Code written by human	0 lines (prompt-only)
Engine / tools beyond model	Not disclosed

Costs now – and how they scale

$40 for 39 prompts works out at roughly $1 per prompt on average. That’s reasonable for a visual prototype, but costs tend to climb when you ask a model to:

• Generate larger asset packs or longer scripts.
• Refactor whole projects repeatedly.
• Debug iterative builds where context has to be re-supplied.

Practical cost controls:

• Set an upfront budget per feature (e.g., £20 per movement tweak sprint).
• Version prompts and reuse context – avoid re-describing the entire project each time.
• Ask the model to output plans and checklists before generating large artefacts.
• Cache assets and only regenerate deltas when requirements change.

Why this matters for UK developers and studios

For UK indies, students and prototypers, this shows a realistic path to a third-person controller and a navigable 3D scene in a weekend without touching code. That’s a big leveller: you can validate themes, camera feel and traversal early, before committing to a tech stack or hiring specialists.

There are trade-offs to weigh:

• Data protection: if you upload proprietary art, text or level designs to a vendor, ensure UK GDPR compliance and read the tool’s data retention policy.
• IP and licensing: check who owns generated assets, code and animations – and whether outputs may include restricted components.
• Vendor lock-in: models, plugins and project formats can be hard to migrate later.
• Sustainability: model inference has an environmental footprint. If that matters to your studio, understand the energy and water implications of heavy AI use. See my explainer on data centre cooling and water cycles.

Pitfalls of AI-only game development

Impressive demos are one thing; shipping is another. Expect friction in these areas:

• Maintainability: AI-generated projects can drift and become inconsistent without strict versioning and a clear file hierarchy.
• Reproducibility: small prompt changes may yield big differences – not great for stable builds.
• Performance tuning: draw calls, physics steps and navmesh updates need profiling; models are weak at sustained engine-level optimisation without tight constraints.
• Gameplay depth: combat, AI behaviours, inventories and progression require coherent state management, not just surface-level scripts.
• Cross-platform inputs: keybinds, controllers and accessibility settings need deliberate design and testing.

A pragmatic roadmap: from demo to playable loop

Based on the Reddit post’s next steps, here’s a sensible order of operations:

1. Define the core loop: one sentence (explore – fight – loot – upgrade – repeat).
2. Interaction system: pick-up, talk-to, open/close, with clear prompts and UI feedback.
3. Combat slice: one enemy type, one player attack, hit reactions, health and death states.
4. Save/load: at least a checkpoint system to support iteration.
5. Basic progression: a lightweight inventory or skill upgrade.
6. Performance pass: target a frame budget and measure against it.
7. Playtesting: 10-minute loop with success/fail conditions.

You can ask the model to produce a test plan, scene hierarchy and naming conventions before generating code or assets. That upfront structure reduces entropy later.

Prompting tips for third-person RPG prototypes

• Describe the player experience in verbs and constraints: “snappy stops”, “90-degree strafe within 0.25s”, “camera offset 3m back, 1.5m up”.
• Lock numbers: speeds, accelerations, camera lags, FOV, and export them as tweakable variables.
• Request a clean folder and prefab hierarchy: list it before generation and enforce it across iterations.
• Version prompts and outputs: keep a changelog so you can roll back behaviours.
• Ask for a minimal scene first, then layer in art and VFX once the feel is right.

What we still don’t know

• Engine and pipeline: not disclosed.
• How assets are generated or licensed: not disclosed.
• Performance on mid-range hardware: not disclosed.

As the creator shares more, watch for details on the toolchain and how well the AI maintains project structure across larger features.

Bottom line

This is a credible proof that modern models like muranyi-3 can get you from a blank page to a third-person 3D sandbox in a weekend, with no manual coding. The leap from there to a fun, balanced RPG is still substantial, but the cost and time-to-first-playable are clearly falling.

If you’re in the UK and considering an AI-first workflow, start small, document ruthlessly, and keep an eye on compliance, IP and costs. Then iterate – quickly, but with guardrails.