Modern Creator
Nate Herk | AI Automation · YouTube

Google Is BACK (Gemini 4 Neon Tested)

A 9-minute reality check on whether Gemini 4 Neon actually beats Claude Opus 5.5, with viral demos, benchmark numbers and a head-to-head test.

Posted
today
Duration
Format
Review
educational
Views
2.8K
178 likes
Big Idea

The argument in one line.

Gemini 4 Neon is a strong, cheaper complement to Claude for visual builds, debugging and long documents, but a lower price per token does not guarantee a lower price per task, so test it on your own work before switching.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…
  • You pay for Claude today and want to know whether adding or switching to Gemini 4 Neon is worth it for your own projects.
  • You build prototypes, landing pages, dashboards or 3D demos and want to know which model produces the best visual output.
  • You run API jobs where cost per task matters and want real numbers on token usage, not just price per million tokens.
SKIP IF…
  • You want a rigorous, large-sample benchmark. The author's own test is a handful of prompts and he says so.
  • You already use Gemini daily and only want setup or prompting tutorials. This is a model comparison, not a how-to.
TL;DR

The full version, fast.

Google's Gemini 4 Neon scores 61 on the Artificial Analysis index versus 59 for Claude Opus 5.5, at a lower cost per benchmark task ($6.44 versus $10). Community demos show it excelling at 3D and visual builds, and it beat rivals on a 105-bug fixing test and unblocked a developer stuck for two weeks. In the author's own test, Neon and Opus tied on a 3D city and a dashboard, but Neon wrote more tokens and cost slightly more on one task. His advice is to add Neon beside Claude for visual work, debugging, huge documents and cost-sensitive API jobs, and keep Claude Code as the home base for long agent runs.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →
Chapters

Where the time goes.

00:00 – 00:20

01 · Cold open

States the claim that Neon beats Opus on the leaderboard for 25% less and promises demos, failure points and a head-to-head.

00:20 – 02:36

02 · Viral demos

A robot dog built in 3D from one image, an animated rain scene from a still, a destructible voxel arena, fixed broken programs, and Eclipse Village.

02:36 – 03:32

03 · Real-work tests

Google's ski simulator demo, the 105-bug test where Neon scores 63, and a developer unblocked in 20 minutes.

03:32 – 05:24

04 · Where Neon is strong

Four strengths: visual builds, fixing and debugging, huge documents, and cost.

05:24 – 05:44

05 · Community Opus comparisons

Watch configurator results show Neon is cheaper but Opus's output is better.

05:44 – 07:33

06 · The author's own test

Same prompts to Neon and Opus 5.5 for a 3D city and a coffee dashboard, with time, token and cost receipts plus trick questions.

07:33 – 08:52

07 · Should you switch

Add Neon beside Claude for visual work, bugs, big documents and cost-sensitive jobs, but keep Claude Code as home base.

08:52 – 09:14

08 · Pricing note and close

Carbon's price doubles December 1 while Neon stays flat, and a reminder to test on your own work.

Atomic Insights

Lines worth screenshotting.

  • A cheaper price per token does not mean a cheaper task: in one test Neon cost 37 cents against Opus at 32 cents because it wrote about 25,000 tokens to Opus's 16,000.
  • Many of the viral model demos come from long, detailed specs, so the prompt deserves part of the credit for the result.
  • Neon scored 61 on Artificial Analysis against Opus 5.5 at 59, yet running the suite costs $6.44 per task versus $10 for Opus and $26 for Fable 5.2.
  • Vendor benchmarks deserve a grain of salt: Google's own long-context recall number is 95% for Neon versus 67% for Opus.
  • Given one still image, Neon downloaded a depth model, sliced the picture into layers and built an interactive rain scene with its own sound.
  • On a 105-bug planted-bug test, Neon at its highest setting scored 63, just above GPT-6.2 Astra at 62.7 and Fable 5.2 at 58.
  • Neon's best use today is adding it next to Claude, not replacing Claude, since the right model depends on the specific job.
  • Batch pricing halves Neon's cost to $1.50 in and $7.50 out per million tokens, which matters for high-volume API work.
  • A watch-configurator test showed price is not quality: Opus cost $2.74 for a 42-part watch while Neon cost $1.86 for a nine-part watch with broken interactions.
  • Both models correctly refused to invent a pandas method that does not exist, so a small trick-question test showed no hallucination difference.
  • Having one model review another's work (Codex reviewing Claude, Gemini reviewing Codex) is a practical way to use several models at once.
  • Gemini 4 Carbon's intro price of $2 and $10 doubles to $4 and $20 on December 1, while Neon stays at $3 and $15.
Takeaway

Add Neon beside Claude, don't switch

WHAT TO LEARN

Neon is a genuinely strong and cheaper option for specific jobs, but benchmark wins and viral demos do not replace testing it on your own work.

  • Viral demos often come from detailed specs, so judge a model by how it handles your own prompts, not by someone else's best result.
  • Neon shines on visual builds like 3D scenes, landing pages and dashboards, and on grinding through specific broken code.
  • On long-document work, Google's own recall numbers favor Neon heavily, but vendor benchmarks deserve a grain of salt.
  • On Artificial Analysis, Neon scores 61 versus Opus 5.5 at 59, at $6.44 per task versus $10, and $26 for Fable 5.2.
  • Price per token is not price per task: a model that thinks and writes more can cost as much as a pricier one, as the 37 cents versus 32 cents city test showed.
  • Lower cost can mean lower quality: Opus built a 42-part watch for $2.74 while Neon built a broken nine-part one for $1.86.
  • Both models passed trick questions and a logic puzzle, but a few prompts say nothing about long-running agent hallucination.
  • Route work by use case: Neon for visuals, bugs, huge documents and batch API jobs, and keep your long agent runs where they already work well.
  • Using one model to review another's output is a practical way to get second opinions without committing to a single vendor.
Glossary

Terms worth knowing.

Artificial Analysis
An independent leaderboard that scores AI models on an intelligence index and reports the cost of running its test suite.
Inverse kinematics
A technique that works out joint angles so a limb's end, such as a foot, lands exactly where it should. It keeps animated feet planted on the ground.
Long-context recall
How reliably a model finds a specific fact buried inside a very large input, such as a million-token document set.
Batch pricing
A discounted rate for API jobs that are submitted together and processed later instead of in real time.
Resources

Things they pointed at.

00:00productGemini 4 Neon
04:40toolArtificial Analysis
00:54toolDepth Anything V2 Large (Hugging Face)
01:36toolAnti-gravity
03:27channelHacker News
Quotables

Lines you could clip.

06:54
“A cheaper price per token doesn't automatically mean it's going to be cheaper per task or per job.”
A concrete, counterintuitive cost lesson with no setup needed→ TikTok hook↗ Tweet quote
07:33
“It's not really a matter of which model is the best, it's which model is the best for this specific use case.”
A clean decision rule for model choice→ newsletter pull-quote↗ Tweet quote
08:52
“Don't take the 'it beats Opus' title at face value. Test everything on your own work before you move anything over.”
Short, direct advice that cuts through launch hype→ IG reel cold open↗ Tweet quote
The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

Google just released Gemini 4 Neon and it's actually beating Cloud Opus on the artificial analysis leaderboard while also costing 25 % less. So if you're paying for Cloud right now, you're probably wondering if you should switch over to Gemini. And in this video, I'll show you the best things that people are building with it, the proof of where it actually breaks, and then my own head -to -head against Opus.
So let's not waste any time and just get straight into this one. So the first thing I wanted to show you guys is the bugged dev. He actually gave Neon one image of a robotic dog with a railgun on its back and basically said, build this in 3D.
And he didn't tell it anything about physics or animation. And you can see what came back here. It's running 240 hertz physics and it worked out the forces on, you know, all of the legs and it's using inverse kinematics so that the feet actually plant and it's got a walk, a trot and a gallop.
And that post did... Really good. It did 150 ,000 views in a day.
And it was just really impressive to see Gemini Neon be able to understand like the physics and the 3D elements here. Now this next one shows what the model does when nobody's telling it how. So Ashutosh gave it one still image and then asked it to animate that image in 3 .js and that was all he said.
And so Neon was able to go off and download a depth model from Hugging Face, ran it locally on his Mac to figure out what's close and what's far, and then sliced the picture into layers and then built this output that you guys are seeing right now. You can see the rain is live, you can splash in the puddles, you can brush the curtains, and it even made its own rain sound.
It's just very impressive what it was able to do when it applied its own logic and reasoning. Then here's a user named Chubby, who had early access and spent a whole day testing it inside of anti -gravity, and Neon built him 17 interactive demos. So this one right here is called Terror Breaker.
It's a destructible voxel arena, and he only asked for destruction and a reset button. And so Gemini Neon added three different tools that actually behaved differently. So the cannon rips out huge chunks, and the chisel just chips off a few blocks, and it held 60 frames per second.
And then Chubby actually gave it three broken programs, and you can see the before and after here. A booking checker went from 1 out of 5 to 100%, a task scheduler went from 8 out of 14 to 100%, and then an async loader went from 10 out of 16 to 100%. And there's so many more other things like this, like this historical sailing ship, which was just one prompt, and the water and the hull look really, really clean.
And this one's from Emily. It's called Eclipse Village. The moon's shadow is sweeping across this little voxel town, and then you can see there's lights that are turning on house by house as it passes.
Now, if you do look at this specific prompt, though, it's really long. You know, she spelled out how many houses, where the camera should sit, and exactly what happens in every couple seconds of this loop. So a lot of these best results you're seeing are coming from people who also gave Neon a good spec and gave it, you know, a lot of good direction and set, I guess, you know, the standard.
And of course, when Google launched this model, they're going to come out with their own use cases too. So they showed off a demo of a first -person ski simulator on the real terrain of Mount Blanc, and it had over 10 ,000 lines of custom shaders and even things like avalanches in there. So anyways, just some quick visual demos for you guys, but I know most of us aren't really building stuff like that for clients, so let's talk about some real work.
Here you can see an example where Powell took two real code repos, planted 105 bugs back into them, and then told each model to find and fix whatever it could. And Neon, on its highest setting, scored 63, which is just above 6 .2 Astra at 62 .7 score. And I know a lot of people have mixed feelings about Astra 6 too, but either way...
but Neon also scored above Fable 5 .2 at 58. And then I also came across this comment on Hacker News where a developer had been stuck for two weeks on some low -level graphics work using OpenAI's model on one computer and Fable 5 .2 on another, and he said that Neon was able to unblock him from this error that the other models couldn't figure out, and Neon unblocked him in about 20 minutes.
So after all the testing and going through use cases and hearing what people are saying about it, it seems like Neon is really strong in four places. So the first one is visual builds. So things like, you know, those demos we saw earlier, 3D scenes, games, landing pages, dashboards, basically anything that you can see in a browser.
And that's where almost all of this viral stuff is coming from. Now, the second thing is fixing and debugging. So that bug test and Chubby's broken programs that we talked about and that graphic story.
all point the same way, which is that when you hand it something that's very specific, that's broken, it's going to be really good at grinding through it and figuring out where it broke and why. Now, the third one is huge documents. You know, it's got a million token context window, which nowadays is pretty standard, but on Google's own numbers, it's way ahead of Opus at finding things that are buried in really long context, 95 % versus 67%.
Now, obviously that was their own benchmark, so I always take those with a grain of salt, but still, that's a big gap. That benchmark also lines up with what Google is pitching this model for, which is things like spreadsheets, PDFs, billing statements, all that kind of like knowledge work stuff. And then the fourth thing here about Neon that's pretty cool is cost.
So on the artificial analysis, which is the independent leaderboard that everyone's been screenshotting, Neon scored a 61 and Opus 5 .5 scored a 59. And running their test suite costs $6 .44 per task with Neon, but with Opus 5 .5, it's $10.
And with Fable 5 .2, it's $26. And Fable is obviously like, in my opinion, the smartest model, and it's the smartest model on the board. But Neon here gets you pretty close to that level of intelligence for just a quarter of the price.
So that is definitely very interesting. And Google has always been putting out models that are pretty fast and pretty cheap. So here's another test from KC.
Same prompts to Opus 5 .5 and to Neon. Build a watch configurator. Opus here cost...
$2 .74 and built a 42 part watch when Neon cost $1 .86 and built a nine part watch where the interactions were broken. So yeah, it's cheaper, but you can see it's not close. And then another guy ran a similar test where Neon cost about half, right?
$3 .50 compared to Opus at $7 .20. And even though he did like the detail that Neon added, he said that he liked Opus's output much better. And obviously a lot of this stuff is subjective.
So the best advice is really just to bring Gemini into your own setup and just see how it performs on your own skills and things like that. So of course, I'm going to take my own advice here, and I wanted to see for myself. I had Claude send the exact same prompts to Neon and Opus 5 .5 through the API, you know, default settings on both, and I just shot off those prompts.
The first one was a 3D coastal city at sunset with a lighthouse, waves, and cars. So Neon's output is right here on the left, and you can see that it's pretty cinematic. We've got the sun, we've got the water and the hills, and then Opus's is on the right.
And it went for more of like an actual city with the street grid, cars, the lighthouse beam sweeping. Now I'd call this... a tie right it's pretty subjective and they just picked different styles so it was tough to declare a winner here but it's interesting to see how they interpreted that prompt differently now the second one was a dashboard for a coffee subscription company and again pretty much a tie both look like real products and both even kept the numbers consistent across the cards But let's talk about the actual receipts here.
On the Citi test, Neon took about 3 minutes and 17 seconds, and Opus took 2 minutes and 16 seconds. Neon wrote about 25 ,000 tokens, and Opus wrote about 16 ,000 tokens. So even though Neon is cheaper per token, Neon cost 37 cents in this demo, while Opus only cost 32 cents in this demo.
On the Dashboard test, they basically cost the same, 40 cents versus 41, so a cheaper price per token. doesn't automatically mean that it's going to be cheaper per task or per job because Neon apparently seems to think a little bit more and write a little bit more so Opus here is a bit more like efficient in the way that it solves the problem or creates the outputs.
I also threw a few trick questions at both these models. I asked how to use a pandas method that doesn't exist and both of them told me that it doesn't exist instead of making something up which obviously was good. I assume nowadays most models would do that.
They also both nailed a really annoying formatting test and a logic puzzle as well. So in my small test, I didn't see the hallucination problem, but keep in mind that was just a handful of prompts, not hours of long -running agents that are delegating work out to sub -agents and things like that as well. So should you switch?
So the question of should you switch, it's not really a matter of which model is the best, it's which model is the best for this specific use case. And for most of you guys, I would just say that you can add Neon next to Cloud instead of switching. If you build things that are very visual like prototypes, you know, landing pages, interactive demos, anything 3D, then go ahead and try Neon right now.
And I'd say the same thing if you're stuck on a bug, or if you need to throw a giant pile of documents at the model, or if you're running a lot of API jobs where cost matters, because they do have batch pricing, which cuts it in half to $1 .50 and $7 .50 for the input and output tokens. But I don't know, for me personally, if it ain't broke, don't fix it.
I'm going to keep Cloud for my long agent runs inside of Cloud Code, where I'm pretty much doing my day -to -day and driving from. And then of course, I'm going to experiment a little bit on different types of projects and running other sorts of things through Gemini to see how it feels. because i obviously do have different subscriptions and i use a bunch of different models but i kind of treat cloud code as my home base and then i you know will delegate out work to different models when i need other opinions or when i'm stuck somewhere things like that I think it's really powerful to have like Codex review Claude's work or Gemini review Codex's work and things like that as well.
And one more thing on price, there's obviously different models of Gemini 4. So carbon is on intro price right now. And on December 1st, it doubles to $4 and $20, but neon stays at $3 and $15.
So after this month, neon is the cheapest way to get carbon level scores from Google. So yes. I do think that Neon is a pretty impressive model.
It's very good. Just don't take it as like the, it beats Opus. Don't take that title at face value.
And obviously, like I said earlier, just test everything on your own work before you move anything over. But anyways, guys, that is going to do it for this one. So if you enjoyed the video or you learned something new, please give it a like.
It definitely helps me out a ton. And as always, I appreciate you guys making it to the end of the video and I'll see you on the next one. Thanks everyone.
The Hook

The bait, then the rug-pull.

Google's Gemini 4 Neon is topping a leaderboard against Claude Opus 5.5 at a lower price, and the internet is full of jaw-dropping demos. Nate Herk sorts what is real from what is hype, then runs his own head-to-head.

Frameworks

Named ideas worth stealing.

03:32list

Where Neon is strong

  1. Visual builds
  2. Fixing and debugging
  3. Huge documents
  4. Cost

Four areas where Neon stands out, drawn from community demos, benchmarks and pricing.

Steal fordeciding which model to route a given task to
CTA Breakdown

How they asked for the click.

VERBAL ASK
08:52subscribe
“If you enjoyed the video or you learned something new, please give it a like.”

A brief, low-pressure like request at the very end after the advice.

Storyboard

Visual structure at a glance.

open
hookopen00:00
viral demos
valueviral demos00:23
105-bug test
value105-bug test02:55
where Neon is strong
valuewhere Neon is strong04:38
own head-to-head
valueown head-to-head05:44
should you switch
valueshould you switch08:01
sign-off
ctasign-off09:04
Frame Gallery

Visual moments.

One-click upgrade to your Google

Get more breakdowns in your search results

Add Modern Creator as a preferred source and Google shows you more of our breakdowns in Search, Top Stories, and AI Overviews. It only changes what you see, and you can undo it in your Google settings anytime.

Add to Preferred SourcesOpens your Google source preferences with us pre-loaded. Tick the box and you're done.
Watch next

More from this channel + related breakdowns.