The Vibe Father
Model Comparison
Google's lineup has a wrinkle that trips people up: the higher version number isn't the better coding model. Gemini 3.1 Pro sounds like the premium option, but on our board Gemini 3.5 Flash — the newer, cheaper, faster release — actually outscores it on the benchmarks that predict real coding work. So the honest question isn't "Pro or Flash," it's "which Gemini should you point at your codebase?" And the data has a clear answer for most people. We run both live at /benchmarks.
What each one wins
Gemini 3.5 Flash wins the coding fight, plainly. It leads on SWE-bench Verified (79.3 vs 75.6), on Terminal-Bench (76.2 vs 70.7), and it's cheaper and faster on top of that. That's a clean sweep on the two benchmarks that matter most for repository surgery and agentic shell work. Flash also streams at 167 tokens per second against Pro's 147 — both quick, but Flash is quicker — and costs $1.5/$9 against Pro's $2/$12. Newer, cheaper, faster, and better at coding. That's an unusual and decisive combination.
Gemini 3.1 Pro's one win is LiveCodeBench: 88.5 against Flash's 87.6. It's a slim 0.9-point edge, but it's a real one, and it lands on exactly the kind of task where Pro's deliberate style helps — contest-style and self-contained algorithmic problems. If your work is heavy on that flavor of coding, Pro's single benchmark advantage is worth knowing about.
The numbers side by side
Our Vibe Coding Index weights SWE-bench Verified at 40%, Terminal-Bench and LiveCodeBench at 30% each.
| Model | SWE-bench Verified | Terminal-Bench | LiveCodeBench | Price (in/out per M) | Speed (tok/s) |
|---|---|---|---|---|---|
 Gemini 3.1 Pro | 75.6 | 70.7 | 88.5 | $2 / $12 | 147 |
| Gemini 3.5 Flash | 79.3 | 76.2 | 87.6 | $1.5 / $9 | 167 |
The table tells the whole story. Flash leads by 3.7 on SWE-bench and 5.5 on Terminal-Bench — meaningful margins on repo and terminal work — while trailing by just 0.9 on LiveCodeBench. And it does that while being cheaper on both token ends and faster on throughput. When the "budget" model beats the "pro" model on most axes, the naming is the only confusing part.
Why does this happen? It's a quirk of how Google versions its lineup rather than anything mysterious. The "3.5 Flash" release is simply newer than "3.1 Pro" — a later generation that folded in improvements to coding and agentic behavior, then shipped in the cheaper, faster Flash tier. Version numbers within a vendor's family don't map cleanly onto capability across generations; a fresh mid-tier model routinely leapfrogs an older top-tier one, and that's exactly what we're seeing here. The lesson generalizes: never assume the bigger number or the "Pro" label is the stronger coder without checking a benchmark. We've watched the same pattern play out across labs all year, which is the entire reason we keep a live board instead of trusting marketing tiers.
The price math
On our reference heavy month of 50M input and 10M output tokens, Gemini 3.5 Flash runs 50 × $1.5 + 10 × $9 = $165/month. Gemini 3.1 Pro runs 50 × $2 + 10 × $12 = $220/month. So you pay $55 more per month for the model that loses on SWE-bench and Terminal-Bench and wins only LiveCodeBench by under a point. For most workloads, that's paying more to get less. We put the full budget picture in our cheapest coding models guide.
Who should pick which
Pick Gemini 3.5 Flash for essentially all general coding. Repo surgery (SWE-bench) and agentic shell work (Terminal-Bench) are where most engineering time goes, and Flash leads both while costing less and running faster. If you were about to reach for "Pro" because the number is higher, stop — for coding, Flash is the correct default, and it's not a close call.
Pick Gemini 3.1 Pro only if your work is specifically contest-style or algorithmic and that last point of LiveCodeBench matters to you. It's the one seat where Pro leads, and even then the margin is 0.9 points against a cheaper, faster sibling. Outside that narrow case, we can't find a coding workload where Pro is the smarter buy over Flash today.
The Vibe Father lesson here is simply to let the data pick, not the version number. Run Flash as your Gemini default and reserve Pro for the narrow LiveCodeBench-heavy niche where it earns the extra spend. We map seats to models in the best model for each agent role.
Verdict
Which Gemini for coding? For almost everyone, Gemini 3.5 Flash. It outscores Gemini 3.1 Pro on SWE-bench and Terminal-Bench, costs $55/month less on our reference workload, and streams faster — a rare case where the newer, cheaper model is simply the better coder. Pro's sole advantage is a sub-point LiveCodeBench lead, relevant only for contest-heavy work. Don't let the version number decide for you. Read the full cases in our Gemini 3.5 Flash review and see the standing on the live leaderboard, cross-checked against our best coding model rankings for 2026.
