[KongchangAI]
· 3 min read· 1,947 words

Gemini 4 Neon Builds a Minecraft Clone in One Shot: Magic and Faceplants

Gemini 4 Neon Builds a Minecraft Clone in One Shot: Magic and Faceplants

Gemini 4 Neon excels at long context and multi-agent work, but is weak on one-shot physics and needs careful cost planning.

Based on a 30-minute hands-on video, this article breaks down Gemini 4 Neon's real capability boundaries. Neon is priced mid-tier in the Gemini 4 family ($3 input / $15 output), slightly above the comparable-model median, with the extra high gear ballooning bills due to verbose output. Benchmarks show it far ahead on long-context tests (GraphWalks 95.2%) and multi-step harness SWE Sweep (39%) versus Opus, but only 12.8% on the raw single harness and roughly even on Terminal Bench. The Slash Swarm multi-agent setup with 8 parallel workers can complete complex 3D games with multiplayer verification, while cold-start one-shot prompts visibly break on shooter frame rates and Minecraft water physics. The author's playbook: use Neon + Swarm + verification loops for frontend and big refactors, Hydrogen or GPT 6.2 Sol for cheap high-frequency tasks, and leave one-shot terminal jobs to Opus.

Introduction: Does Google Finally Deserve an Apology?

For the past year, Google has been consistently outgunned by Claude and GPT in code generation. But the release of Gemini 4 Neon has visibly loosened that grip. A developer on YouTube ran a 30-minute head-to-head test: same prompt, same high-compute tier. Claude Opus 5.5 delivered a 748-line gray courtyard for $6.47, while Gemini 4 Neon wrote over 4,000 lines in one go — complete with glowing crystal temples, a meteor boss, and storm lightning — for roughly $4.

But don't crown it just yet. The author then tested his own cold-start one-shot prompts on an interactive Mac OS clone, alpine skiing physics simulation, a Minecraft sandbox, and a desert shooter — some results were stunning, others had physics that simply fell apart. This article breaks down Neon's real capability boundaries, the API pricing traps, and when it's actually worth using, based on the hands-on data from that video.

Google Gemini 4 series pricing comparison

Pricing and Specs: The Mid-Tier Slot, With Some Fine Print

According to Google's November 18 release notes, Gemini 4 Neon sits in the middle of the Gemini 4 family: $3 per million input tokens, $15 per million output tokens. Cached input gets a 95% discount, dropping repeated context to $0.15 per million tokens, with a full 1M-token window.

Compared across the product line: the flagship Carbon is $4 input / $20 output (promotional price $2.10 until November 30), while the lightweight Hydrogen is $1.50 / $7.50 and free for everyone in the Gemini App. Neon is only available to paid Pro, Ultra, and API tiers — it can run in Semi but isn't free, and is currently accessible via Google Anti-Gravity and AI Studio.

One easily overlooked detail: an early model card described Neon as "trained from Hydrogen, with Flash-tier speed and pricing," and that sentence was quietly removed. In its place are four thinking gears — low, medium, high, and extra high — reaching roughly 110 tokens/sec at the top end, nearly double Carbon.

But $3 input and $15 output sounds cheap until you realize Artificial Analysis puts the median for comparable models at $2 and $10. In other words, Neon's sticker price is slightly above median, and whether it actually saves money depends entirely on how verbose it gets at each thinking gear.

Benchmarks: Long Context Is Home Turf, Single-Shot Harness Is the Weak Spot

On the official scorecard, Neon punches hard. It scores 61 on the Artificial Analysis index, beating Claude Opus 5.5's 59 and GPT 6.2 Sol's 57. On Cursor Bench it's 65.4 versus Opus's 58. In the multi-step provider harness SWE Sweep, Neon jumps to 39% — nearly four times Opus's 10.1%.

Cursor Bench comparison data

Flip it over and the story changes: on the raw single-harness SWE Sweep Mini it scores only 12.8%, with Opus still ahead by about 18 points; Terminal Bench 4.1 and Frontier Code are basically a wash. Long-context workflows are Neon's kingdom — 75.8 on Agent's Last Exam, 84 on Riemann BenchMath, and 95.2% on GraphWalks at the million-token window, where Opus drops to 66.8.

Artificial Analysis's independent testing reveals the real API bill: the low gear scores 44 at just $0.75 per test, finishing in 4 minutes; medium scores 55 at $1.90; high scores 60 at $3.74; extra high scores 61 but the bill jumps to $6.44 — because that gear burned through 283 million verbose output tokens over 21.5 minutes.

Even with that verbosity explosion at extra high, compare full-task costs: Opus 5.5 runs $10.04 per Intelligence Index round, and Claude Fable 5.2 hits $26.54. On Agent Arena across 4,000 real user sessions, Neon at default high ranks third at $2.60 per session — exactly half of Opus's $5.89, and ahead of GPT 6.2 Astra's $3.18. Still, the smaller GPT 6.2 Sol remains king of that leaderboard.

Harness in the AI coding context doesn't refer to a specific model but to the execution framework wrapped around the model: it decomposes tasks, calls tools (terminal, browser, test runner), validates intermediate results, and retries on failure. The same model can perform wildly differently in different harnesses — Neon's 12.8% on the raw single-harness SWE Sweep Mini versus 39% in the multi-step provider harness is a direct illustration of this effect.

SWE Sweep is a class of code-repair benchmarks that typically pull issues from real open-source repos, require the agent to locate and submit a patch, and judge success by whether tests pass. "Raw single harness" means one prompt with no external verification loop; "multi-step harness" allows the agent to iterate and debug. The larger the gap between the two scores, the more the model relies on external scaffolding rather than nailing it in one shot.

GraphWalks specifically tests long-context reasoning: it scatters information across extremely long text in a graph structure and requires the model to trace relationships across multiple nodes to answer. Neon's 95.2% at the million-token window versus Opus's 66.8% shows the former's attention mechanism decays more slowly on ultra-long inputs — directly valuable for whole-repo refactors and cross-file dependency analysis.

Agent's Last Exam and Riemann BenchMath focus on multi-step agent tasks and mathematical reasoning respectively — the former on planning within tool-call chains, the latter on correctness of formal mathematical derivation. Together they sketch Neon's profile: strong long context, weak one-shot blind attempts.

Multi-Agent: 8 Workers Make the Magic Actually Happen

That earlier pair of SWE Sweep numbers — 12.8% raw versus 39% in a harness — explains every difference in the real-world demos that follow. Lock an isolated agent into a single blind prompt and edge cases will inevitably slip through. But in Google Anti-Gravity, using Slash Swarm to split a build task across 8 parallel Neon workers that write, check, and test simultaneously, the outcome is completely different.

Look at what Neon built in Anti-Gravity with 8 coordinated workers: a complete synthwave mini-golf game called Neon Putt 84. One worker scaffolded the type skeleton, others wrote custom Neon shaders and ball physics, then Neon opened an embedded browser itself and played every hole to verify collision — and even got real-time multiplayer working.

Neon Putt 84 built by 8 workers in Anti-Gravity

On pure visual taste, Jan's one-shot cathedral test is convincing: Neon cost $2.67, GPT 6.2 Sol cost $1.69. Sol looks fine until you look left — Neon carved actual flying buttresses, arched stained-glass windows, and a vaulted interior hall with red carpet. The same story plays out in community 3D showcases: Lumina's glowing cherry-blossom pagoda and golden-hour seaplane wake, Bee's wizard bridge dynamically lit by a pixel phoenix, and Pranav's three-mountain cyclist.

Slash Swarm is the multi-agent orchestration mechanism in Google Anti-Gravity: users split a large task into subtasks via slash commands, dispatch them to multiple parallel Neon workers that each write code and run tests independently, and a master agent aggregates and verifies. Its value is turning "one blind shot" into "many parallel attempts plus cross-validation," bypassing the single agent's tendency to skip edge cases.

It's worth distinguishing: Swarm doesn't make the model itself smarter — it uses engineering to amplify the model's usable compute and verification density. That's precisely why the same model that breaks water physics on a cold-start one-shot prompt can complete a full game with collision detection and real-time multiplayer when 8 workers cooperate.

Cold-Start Hands-On: From Stunning to Physics Faceplant

Leaving the Twitter demo videos behind, the author cold-started his own prompts from scratch. The first was an interactive Mac OS browser clone — and this one really worked: Finder directories functioned, the calculator did real math, light/dark theme switching was clean, and you could even type notes directly inside the fake OS window.

Next was a 3D desert action shooter. The author stressed he didn't cherry-pick a good-looking failure: actual gameplay was poor. Frame rate stuttered around 20 FPS, reload logic broke — showing reload while there were still rounds in the magazine — walls and stairs clipped straight through the camera, box enemies felt broken to hit, and you died fast with only 6% to 10% accuracy. Great thumbnail, painful to play.

The Minecraft voxel clone had the same problem. Walking past oak trees and hitting the sunset-to-night shader toggle was genuinely impressive for the first 5 seconds — until you walked into the ocean and started digging. Look beneath the shoreline: the water physics were completely broken. Seawater that should have flooded the mine pit downward carved out dry air pockets beneath a static flat blue water sheet, with the water surface floating in midair. Even that cool CAD folding banquet table followed the same pattern: empty-hinge kinematics and collision math worked when unloaded, but when you placed a 20 kg weight and folded the table simultaneously, frame rate dropped to 20 FPS, the weight scattered through the folding frame, and the telemetry panel cheerfully reported "no clipping."

Floating water surfaces and air pockets in the Minecraft clone

Three Real Traps Hidden in the Numbers

Why does the world's third-ranked model act like a wizard in Anti-Gravity yet fail at water physics on a cold-start one-shot? Three real traps.

Trap one: bash command reliability ranks 55/68. This explains the stuttering frame rates and Minecraft water-physics breakdown the author encountered. When Neon only has one blind shot with no verification loop, it skips edge-case physics to finish fast. Wrap it in Slash Swarm, or do multi-round debugging where it tests its own code, and these bugs disappear.

Trap two: the extra high gear generates 283 million verbose tokens, with a 56-second wait for the very first word — quietly burning through your API budget.

Trap three: on pure API cost per task, GPT 6.2 Sol at roughly a dollar per task still beats Neon's $3.74 at high and $6.44 at extra high. Even though Neon wins big on honesty — 0% test cheating on Terminal Bench — don't pay Neon's output rates for simple background cron jobs.

Thinking gears refer to the tiered setting for how much internal reasoning the model may do before generating a response, from low to extra high, corresponding to different reasoning token budgets. The higher the gear, the more the model tends to unfold multi-step deliberation — accuracy rises but output token count and latency balloon in tandem. The extra high gear burning 283 million output tokens with a 56-second wait for the first word is a direct consequence of an expanded reasoning budget.

Cached input discounts are another billing mechanism: when multiple requests share the same prefix (such as a large codebase context), those tokens can be billed at a steep discount. Neon's cached input drops to $0.15 per million tokens, meaning in refactoring scenarios with repeated calls over long context, the real cost may be far below the sticker price; conversely, short, context-varying calls are unlikely to enjoy this discount.

Practical Playbook: When to Use Neon

After testing both the highlights and the broken water blocks, the author gave a no-nonsense playbook:

  • Frontend, 3D worlds, million-token big refactors: Use Gemini 4 Neon at medium or high gear, pair it with Slash Swarm in Anti-Gravity, and always have it open a browser or run a test loop to catch bugs like the water physics.
  • High-frequency, low-cost API pipelines: Use Hydrogen or GPT 6.2 Sol.
  • Raw one-shot terminal surgery only: Keep Claude Opus 5.5 nearby.

The ultimate question isn't whether Neon can write code, but how much supervision it needs to write it well. On one blind shot, it's the edge-case-skipping student; inside a verification loop, it's the architect who can carve flying buttresses. That distinction determines where you should place it in your workflow.

#Gemini 4 Neon#Claude Opus 5.5#GPT 6.2 Sol#AI code generation#multi-agent Swarm#API pricing
Share:

Related articles