Students Get a Free Year of Gemini Pro. Almost Nobody Uses It.

2026-07-12

I pay for Claude like everyone else. I still made Gemini do most of my writing and generate the images Claude flat-out can’t. Here’s the open-source project that pulls it off.

Sometime in 2025, Google did something quietly generous: it gave students a free year of Gemini Pro. Real, paid-tier Gemini — the good model, the big context window, the works — for twelve months, for free.

And I’d bet most of the students who claimed it have opened it maybe twice.

I know I did. Here’s the honest reason: for actual work — writing code, debugging, thinking through a design — I reach for Claude or ChatGPT, because they’re just better at it. I pay for those. So my free Gemini Pro plan has been sitting in my account like a gym membership I signed up for in January and never used.

That bugged me enough to fix it. This post is about the fix: an open-source project I built with two skills that turn that unused Gemini Pro plan into a genuinely useful workhorse without asking me to give up the smarter models I actually pay for. One (gemini-swarm) makes Gemini do the token-heavy writing. The other (gemini-imagegen) does something my paid model literally cannot: generate images. More on both below.

First, let’s be honest about “smarter”

I kept saying Claude and ChatGPT are smarter than Gemini. That’s easy to assert and annoying to read without proof, so here’s the proof.

TerminalBench 2.1, via OpenAI

This is TerminalBench 2.1, a benchmark that measures how well models actually operate in a terminal running commands, writing code, fixing things — which is exactly the work I care about.

Look at the bottom of that chart. Gemini 3.1 Pro Preview scores 70.7% — last place. Above it, the frontier GPT-5.6 and Claude models cluster between 78.9% and 91.9%. Even the lowest-scoring Claude on the board (Opus 4.8 at 78.9%) is a clear ~8 points ahead of Gemini, and the top GPT is more than 21 points ahead.

So my gut was right. For hard, reasoning-heavy coding, the models I pay for really are ahead. That’s not Gemini-bashing — 70.7% is a capable model. It’s just capable-but-behind, and “behind” is enough reason for a student to spend real money on Claude or GPT and leave the free plan untouched.

But here’s the reframe that started this whole project:

Not all work is hard work.

The insight: planning is cheap, writing is expensive

Think about what a big coding task actually is. Say you’ve got a repo with 20 API-route files and zero tests, and you want tests for all of them.

The hard part is small: deciding what to test, matching the existing style, catching the tricky edge cases. That’s maybe 5% of the effort — and it wants a smart model.

The other 95% is grinding out 20 near-identical test files. That’s not hard. It’s just a lot. And if you make your expensive, smart model do all of it, two bad things happen:

• You burn its context window. Twenty files of boilerplate flood the conversation, and the model gets dumber as its context fills with grunt work instead of your actual problem.
• You burn money. You’re paying premium per-token rates to generate the most mechanical text imaginable.

This is the exact shape of problem where a free tier should be doing the heavy lifting. You don’t need a genius to write boilerplate. You need a genius to direct the writing and a tireless, free intern to actually type it.

I have a genius I pay for. I have a free intern I wasn’t using.

Let’s introduce them.

What I built: gemini-swarm

gemini-swarm is a skill for AI coding agents (I built it for Claude Code; it’s portable to other harnesses). The idea in one sentence:

Your smart, paid model plans and reviews. Gemini does the token-heavy writing in parallel using your free Pro plan.

The smart model becomes an orchestrator. It never writes the twenty files itself. Instead it:

• Decomposes the task into independent subtasks — different files, modules, or research topics that don’t touch the same state, so they can’t conflict.
• Routes each subtask to the right Gemini model: reasoning-heavier chunks go to Gemini Pro, mechanical bulk goes to the faster Flash model. You never get asked which it decides.
• Dispatches all of them at once, as parallel live Gemini sessions running through Google’s Antigravity CLI (agy) — the same CLI that taps your Gemini plan.
• Integrates the results: confirms every file landed, writes a run log, and reports back a short summary — not twenty walls of Gemini output pasted into your face.

The magic trick is context hygiene. A cheap dispatcher subagent actually launches the Gemini jobs, waits for them, writes the log, and hands back only a short summary plus a path. The raw Gemini stdout — all those thousands of tokens of generated code — never enters your smart model’s context. Your orchestrator stays sharp because it only ever sees the plan and the summary, never the grind.

What it looks like

Once it’s installed, you don’t invoke anything special. You just describe the task:

/gemini-swarm auto
Write unit tests for every file in src/routes/. One test file per route,
covering the happy path and the main error cases. Match the existing style
in tests/.

Here’s what happens under the hood:

• It decomposes into ~20 independent subtasks — one per route, no two touching the same file, so there are zero conflicts.
• It routes each one: mechanical test-writing → the fast Gemini model; anything needing deeper reasoning → Gemini Pro.
• All ~20 Gemini jobs run in parallel, each writing its own test file straight to disk.
• The orchestrator integrates: confirms every file landed, writes a run log to .gemini-swarm/logs/, and reports a short summary.

Twenty files got written, and my main agent’s context is still pristine. The token-heavy grind happened entirely inside the Gemini sessions on the free plan.

The economics, stated plainly

Here’s the part that made me actually finish and open-source this.

• The expensive 95% — the boilerplate, the bulk, the repetitive typing — gets absorbed by the free Gemini Pro plan you already have and weren’t using.
• You only spend your paid, premium tokens on the cheap 5%: planning and reviewing. Which is exactly what the smart model is best at anyway.

You’re not choosing between “smart but expensive” and “free but behind.” You’re using each one for what it’s best at. The free plan finally earns its keep, and your paid plan gets more efficient because it’s no longer wasting context on grunt work.

And offloading grunt work is only half of it. There’s a whole category of work my paid model can’t do at all — which is where the second skill comes in.

The other half: teaching Claude to draw

Here’s a limitation people forget about until it blocks them mid-task: Claude cannot generate images. Neither can most text-based coding agents. It’s not a settings toggle or a subscription tier — the model outputs text and code, full stop. Ask it for a logo, an icon, a hero image, an OG card, or even a throwaway placeholder graphic, and the best it can do is describe one or hand you some SVG that looks like a child drew it.

Gemini can. And that same free plan gives you access to it.

So the project ships a second skill, gemini-imagegen, built on the exact same pattern as the swarm: your orchestrator directs, and a Gemini session does the thing it’s uniquely good at. When you (or your coding agent, mid-task) need an image, it dispatches a Gemini session whose generate_image tool produces a real raster image and saves it straight to disk where you asked:

/gemini-imagegen a flat-style logo of a hummingbird in teal and orange,
transparent background, save as assets/logo.png

It also fires automatically whenever a task needs an image (“make me a hero image for the landing page”), and if you ask for several images it dispatches them in parallel — one Gemini job per image — then the orchestrator actually looks at each result to confirm it matches before handing it back. No leaving your editor, no separate image tool, no copy-pasting prompts into a web UI.

The honest kicker: the cover image at the top of this post, and the diagram earlier, were both made this way. My paid model couldn’t have drawn either one. The free plan did — for free.

Try it! — about 5 minutes

Everything’s open source (MIT). You need three things: the Antigravity CLI, a logged-in workspace, and the plugin.

1. Install the Antigravity CLI (agy) — it’s the process that runs each Gemini job:

   # macOS / Linux
   curl -fsSL https://antigravity.google/cli/install.sh | bash
   

2. Log in and trust your project — run agy once, interactively, inside your project. It opens Google Sign-In (this is where your free Gemini Pro plan gets connected) and asks to trust the workspace. Say yes, then quit.

3. Install the plugin (Claude Code) — two separate commands at the prompt:

   /plugin marketplace add Vallykrie/gemini-swarm-skill
   

   /plugin install gemini-swarm@gemini-swarm-skill
   

That’s it. Now describe any multi-file writing task and watch your free plan do the work.

👉 Repo: https://github.com/Vallykrie/gemini-swarm-skill, stars genuinely help other students find it.

The bigger point

I don’t think the lesson here is “Gemini is bad” — it clearly isn’t. The lesson is that we’ve gotten lazy about matching the tool to the job. We pick one favorite AI and funnel everything through it, paying premium rates to make a genius do a data-entry job.

The smarter setup is a little team: the expensive model that thinks, and the free one that grinds. If you’re a student with a Gemini Pro plan quietly expiring in your account, this is the most satisfying way I’ve found to get your money’s worth out of it — which is funny, because it didn’t cost you anything.

Go use the thing you already have.

gemini-swarm is MIT-licensed and open source. If you build something with it or find a rough edge — issues and PRs are welcome.