The GPT-6 Astra One-Shot Game Trend: Both Prompts, Verbatim — And What the Files Actually Contain

TL;DR — The "one prompt, one game" trend around GPT-6 Astra is real, and the two prompts everyone is copying are published verbatim. But "one-shot" is not the same as "instant." The most-shared example took 21 minutes at the highest reasoning setting, and when you download the actual output you find a 5 MB file with the same 2 MB image pasted into it twice. Below: both prompts in full, a breakdown of why the better one works, what OpenAI itself documents about game-making with this model, and a byte-level look at what the files really contain.

Since GPT-6 Astra shipped on 3 September 2026, the thing filling timelines has not been benchmark scores. It has been people pasting a single paragraph into a chat box and getting back a playable browser game. No repo, no build step, no assets folder — one HTML file you double-click.

Two GitHub repositories are the actual source of most of what is circulating, and both went up on 5 September:

Repository	Created	Stars	What it is
Ayi1337/gpt6-astra-one-shot-games	5 Sep 2026	23	Two one-shot tests with the original prompts kept verbatim and the HTML output committed
MartinDelophy/awesome-gpt-6-astra	5 Sep 2026	38	A curated list of 9 browser games plus one particle-art sandbox, in 12 languages including Korean

Star counts read from the GitHub API on 8 September 2026.

Everything below is checked against those primary sources or measured directly from the files. Where a claim is somebody's report rather than something verifiable, it says so.

The two prompts, verbatim

1. Melon Lab — the short one

This is the one people quote because it is almost nothing. Original Chinese, as committed:

用最短的时间设计一款全新概念（物理性质）的半流体西瓜游戏（html游戏）

Roughly: "In the shortest possible time, design an all-new-concept (physical properties) semi-fluid watermelon game (HTML game)."

Twenty-eight characters. It names a genre everyone knows (the watermelon-merging game), demands one novel axis (semi-fluid physics instead of rigid circles), fixes the delivery format (HTML), and stops. Playable demo · source

Note the opening clause: "in the shortest possible time." The creator's own log says they deliberately dropped that phrase for the second attempt. Hold that thought.

2. Mosswing — the one worth studying

Second test, time constraint removed. The creator records it as Xhigh reasoning effort, 21 minutes. Verbatim:

Remaster the classic "tap-to-flap" game — the one where you tap to keep a small
creature airborne while gliding through an endless series of gaps — as a 3D game
playable in a mobile browser. One index.html, opens and plays instantly, no
external assets (CDN libraries are allowed; your call).

Keep the core exactly as everyone remembers it: one-tap control, gravity, gaps
that scroll toward you, one hit and you're done, score is gaps passed. Everything
else is yours to decide: what the creature is, what the obstacles are, the world,
the camera, the feel of the flap, how far to take the visuals. Design an original
character and style rather than copying the original's art. I won't answer
clarifying questions.

I'm judging a complete, elegant, great-feeling piece of work — not a feature list.
Small and finished beats big and rough.

Playable demo · standalone HTML

Why the second prompt works

It is 150 words doing six separate jobs. Each one removes a specific way the output could go wrong.

It anchors on a shared reference without naming it. "The classic tap-to-flap game — the one where you tap to keep a small creature airborne while gliding through an endless series of gaps." That description is worth a page of spec, costs one sentence, and sidesteps the trademark. The generalisation: point at something the model has certainly seen, and describe it well enough that you would recognise it from the description alone.

It fixes delivery before anything else. "One index.html, opens and plays instantly, no external assets." The space of possible project layouts collapses to one, and the result is testable by double-clicking. Most disappointing one-shot attempts fail right here — you get a src/ tree, a package.json, and a build you have to run before you can see whether the game is any good.

It freezes the core loop, explicitly and exhaustively. One-tap control, gravity, gaps scrolling toward you, one hit and you are done, score is gaps passed. Five invariants, stated as facts, nothing left to interpret. This is the part that makes the output feel correct rather than merely impressive.

Then it hands over everything else, by name. "What the creature is, what the obstacles are, the world, the camera, the feel of the flap, how far to take the visuals." This is the clause that separates a good result from a generic one. Enumerating the free variables is an instruction to spend effort there. A prompt that specifies everything gets you exactly what you asked for and nothing more.

It closes the escape hatch. "I won't answer clarifying questions." Without this line a reasoning model will often spend the turn asking what art style you want. One sentence converts a conversation into a delivery.

It states the grading rubric. "A complete, elegant, great-feeling piece of work — not a feature list. Small and finished beats big and rough." Told how it will be judged, the model cuts scope instead of padding it — the opposite of the usual instinct to list more features in the hope of getting more of them.

And the clause from the first test worth not copying: "in the shortest possible time." For a reasoning model, thinking time is the budget the quality comes out of, and asking for speed spends it. The creator removed the phrase on the second run and raised the effort setting instead — 21 minutes, and Mosswing is the entry that ended up on the curated list.

What OpenAI itself documents

Worth reading against the trend, because the officially published game-development workflow does not look like a chat box at all.

OpenAI's case study with Playco describes Playbot, an internal AI IDE the studio built for professional game developers, wired directly into Unity and Godot. The reported results:

• 50% fewer manual fixes required compared with the models Playco used previously.
• From a single greybox scene, the model produced three fully themed prototypes, most of which worked on the first try; one cyberpunk build needed performance corrections.
• The gain is attributed to spatial reasoning and vision — the model places elements in a scene and checks in-engine UI responsiveness itself.

João Vieira, lead product engineer at Playco, frames the change as a shift in what you can afford to try: with ten game ideas, you can now build all ten, play them, and see how each one feels.

That is the real story, and it is bigger than "one prompt." The value is not that a model writes a game — it is that the cost of evaluating an idea drops far enough that you stop having to pick your favourite in advance. The one-shot HTML demos are the consumer-visible edge of the same capability.

I downloaded the outputs. Here is what is in them

Both files, fetched from the repository on 8 September 2026 and measured directly. This is the part nobody checks.

	Mosswing	Melon Lab
File size	701,216 bytes	5,263,530 bytes
Lines	323	209
External src/href to http(s)	0	0
Largest single line	669,555 chars	2,624,939 chars
What that line is	Three.js r160, minified, inlined	A style block plus an embedded PNG
Hand-written game code	≈ 31,658 bytes	—
Embedded images	none	2 × base64 PNG, 1254 × 1254

Two things fall out of this.

The "no external assets" constraint was honoured literally. The prompt permitted CDN libraries — "CDN libraries are allowed; your call" — and the model's call was to paste the entire minified Three.js r160 bundle into the file as a single 669,555-character line. Zero network requests for code. Strip the library out and the actual game is about 31 KB. That is a small, dense program, and its being small is the prompt's doing: small and finished beats big and rough.

Melon Lab's 5 MB is 99.3% one duplicated image. The file embeds a 1254 × 1254 PNG — 1,959,664 bytes decoded — as a base64 data URI, twice, byte-identical (both copies MD5 053d6c3f…). Between them they account for 5,225,820 of the file's 5,263,530 bytes. De-duplicating that single asset would halve the download.

Reproduce it yourself:

curl -sL -o mosswing.html https://raw.githubusercontent.com/Ayi1337/gpt6-astra-one-shot-games/main/mosswing/mosswing.html
wc -c mosswing.html
grep -c -o -E '(src|href)="https?://' mosswing.html
awk '{print length}' mosswing.html | sort -rn | head -1

Neither finding makes the games bad — both are live and both play. But they answer the question the hype does not: a one-shot result is a working artefact, not an optimised one. It ships. Nobody reviewed it.

How much of this trend is actually one-shot?

The curated list is unusually careful about attribution, and reading its own wording is more informative than the headline count. Taking each of the ten entries at exactly what the list says about it:

How it was made, per the list	Entries
One-shot, with the verbatim prompt published	2 — Mosswing, Melon Lab
Single prompt claimed, prompt not published	1 — Pelican Pedal ("has not been independently verified")
Autonomous generation claimed, from descriptions and requirements	2 — Toy2Game, 永恒荒野 (no public source)
Attribution stated, process not described	1 — Magic Carpet Wizard
Explicitly iterative — "not a one-shot test"	2 — Last Beacon, Orbital Garden
Iterative work, Astra attribution still pending confirmation	2 — Sunjing Puzzles, APEX CLUB

So of ten curated projects, two publish a reproducible one-shot prompt, and four are documented as multi-turn work. The list itself carries the caveat plainly: model attribution is author-reported, and the games have not been play-tested for the list. It also states it has no affiliation with OpenAI, and that inclusion is not a benchmark.

That is not a debunking. It is the correct size of the claim: the one-shot game is a real, reproducible thing that a handful of people have demonstrated with their prompts on the table, sitting inside a larger body of ordinary iterative AI-assisted development that is being read as the same phenomenon.

A template you can actually reuse

Stripped to its structure, the Mosswing prompt is six slots. Fill them and you have a prompt with the same shape for any small game:

Remaster/build <a game everyone knows, described in one clause rather than named>
as <the twist — a new dimension, a new physical property, a new input>.

<Delivery constraint: one file, opens and plays instantly, no external assets.>

Keep the core exactly as everyone remembers it: <3-5 invariants, stated flatly>.

Everything else is yours to decide: <name the free variables — character, world,
camera, feel, how far to take the visuals>. Design an original character and style
rather than copying the original's art.

I won't answer clarifying questions.

I'm judging a complete, elegant, great-feeling piece of work — not a feature list.
Small and finished beats big and rough.

Three practical notes on running it:

• Do not ask for speed. Set the reasoning effort high and let it take the time. Twenty-one minutes produced the entry that got curated; the run that asked for haste produced the one with the duplicated 2 MB PNG.
• Name a genre with a fixed loop. Endless runner, merge game, tower defence, one-button flyer. Genres whose rules are common knowledge give the model a complete spec for free. "An RPG" does not.
• Expect to review the output, not just run it. Check for duplicated assets, check the file size, and check that nothing silently reaches for a CDN if you need it to work offline.

What this does not show

Being specific about the limits is more useful than a verdict.

These are single-file browser games in well-worn genres, a few hundred lines plus a library — not evidence about production games, multiplayer, engine work, or anything that has to survive contact with a codebase. The 21-minute figure is one creator's report of one run. No one has published a success rate over repeated attempts at the same prompt, which is the number that would actually tell you how reliable this is. And with two published prompts, the anatomy above is a plausible reading of why they worked, not a tested one. The honest experiment — run the same prompt ten times, at two effort settings, and count how many outputs open and play — has not been done publicly. If you run it, publish the failures too.

FAQ

What is the actual one-shot prompt everyone is sharing?

Two of them, both in Ayi1337/gpt6-astra-one-shot-games: a 28-character Chinese prompt for a semi-fluid watermelon-merging game, and a 150-word English prompt that remasters the classic tap-to-flap game in 3D. Both are quoted in full above, and both outputs are live and playable.

How long does a one-shot game actually take?

The creator of Mosswing records 21 minutes at the Xhigh reasoning setting. Treat the "one click and it is done" framing as marketing: it is one turn, not one moment, and the thinking time is where the quality comes from.

Should I tell the model to work fast?

No. The first test in the same repository opened with "in the shortest possible time," and the creator dropped that phrase for the second run. For a reasoning model, asking for speed spends the budget that the result's quality comes out of.

Why does "I won't answer clarifying questions" matter?

Given an underspecified creative brief, a reasoning model will often spend its turn asking what you want instead of building it. That one sentence converts the exchange from a conversation into a delivery, which is what makes a single turn produce a finished artefact.

Is the output production-ready?

No. Both files work, and both show the marks of nobody having reviewed them — Melon Lab embeds the same 2 MB PNG twice, which is 99.3% of its 5 MB. A one-shot result is a working artefact, not an optimised one. Read it before you ship it.

Is OpenAI positioning this as one-prompt game creation?

Not in its own published material. The Playco case study describes a purpose-built AI IDE wired into Unity and Godot, with the model generating and checking builds in-engine — 50% fewer manual fixes, and three themed prototypes from a single greybox scene. The consumer one-shot demos are the visible edge of that capability, not the workflow OpenAI documents.

---

← Back to all posts