Gemini 3 Pro for Developers: One Week of Hands-On Testing

I’ve been testing Gemini 3 Pro for the past week, and honestly? I’m surprised how well it works.

I’d finally gotten comfortable with my Claude/GPT-4 workflow, and then Google launched this in November and I had to adjust everything again.

But here’s the thing: after forcing myself to rebuild a feature of mine that I’d already finished (yeah, I rewrote working code just to test this), I get the hype. This isn’t your typical “a bit better at benchmarks” release. Deep Think and actual multimodality (not the fake kind) change how you can work.

Let me show you what I mean.

What’s actually different this time

1. Deep Think, or why it actually pauses now

You know how previous models would just… start spitting out tokens? Mid-thought, zero planning, just word prediction?

Gemini 3 actually stops. It thinks. You’ll see “[Thinking…]” in the API response, and at first I thought my connection dropped. Nope. It’s genuinely spending compute time planning its answer before committing.

What I look for:

If you ask it to plan a migration from a monolithic SPA to micro-frontends (hypothetical example, not a project of mine), instead of dumping code it should first ask about the deployment pipeline and the legacy dependencies that would break, then propose a phased rollout. That is the difference I look for in a model that plans before it writes.

The catch: It’s slower. If you’re used to instant responses, the thinking pause feels eternal. But for architecture decisions? I’ll take accuracy over speed.

2. Multimodality without the duct tape

Every model claims “multimodality” now. Usually, it means they duct-taped three different models together and hoped for the best.

Gemini 3 is different: one model handles everything. Text, code, video, audio, images. Same weights, same architecture.

Real test I did:

I recorded a short Loom video of a UI bug (button wouldn’t disable after clicking). No transcript, no code snippets. Just me clicking around and complaining in Spanish.

Uploaded it. Asked: “What’s broken?”

It responded:

• Identified the event handler wasn’t preventing double-clicks
• Pointed to the React component by name (this is what surprised me most)
• Suggested adding a isLoading state with disabled={isLoading}

I checked. It was right. The component name was correct, and it got it from a video.

The weird part: With long videos it seemed to hallucinate component names more easily (my impression, I did not measure it). For quick bug hunts, I haven’t used anything better.

3. Agentic Capabilities (With a Giant Asterisk)

The benchmark results Google published look great on paper, but I have not verified them myself. In practice? It’s… complicated.

What works:

• Running terminal commands (I let it debug a Docker networking issue, and it actually used docker inspect correctly)
• Editing files (made a multi-file refactor without breaking tests)
• Running tests and interpreting failures

What doesn’t:

• It still sometimes tries to run commands that don’t exist (git commit -fix is not a thing, Gemini)
• Gets confused if your project structure is unconventional
• Will confidently suggest deleting files that are actually critical (caught this more than once; always review)

Trust, but verify. Always.

Where it slots into a real workflow

1. Stop writing boilerplate by hand

Forget “vibe coding”. Let’s talk about the stuff you actually hate doing.

How I would approach it (hypothetical example):

For scaffolding a CRUD API you would hand it something like:

“I need a FastAPI endpoint for user authentication. JWT tokens, refresh logic, PostgreSQL with SQLAlchemy. Follow the existing pattern from the /products endpoints.”

With an existing module as context, the pattern is clear. What usually fails with this kind of generation is import paths and environment variables.

Time saved: I did not time it, so no numbers.

The catch: You need a consistent codebase pattern. If your project is chaos, Gemini 3 will reflect that chaos.

2. Code reviews (but not how you think)

I don’t trust AI for full code reviews yet. Where it fits is as a “first pass filter”.

How I’d use it: paste the diff in, let it flag the obvious stuff (hardcoded credentials, missing error handling, SQL injection risks), then do the real review of logic and architecture yourself.

That way it catches the boring stuff and you can focus on whether the code actually solves the problem.

Warning: It will sometimes flag false positives. Once it complained about a .env file that was actually a .env.example. Don’t blindly merge based on AI feedback.

3. Legacy code (where it can shine)

Remember that old jQuery spaghetti nobody wants to touch? The huge context window Google advertises for Gemini 3 fits this well.

How I would approach it (hypothetical example, I haven’t tried it on a real project):

Picture a legacy admin panel in vanilla JS. You would ask it to:

• Identify which files are actually used
• Create a dependency graph
• Rewrite the user management module in React

Expect to fix things like event handling by hand, so treat its output as a first draft.

Pro tip: Do this incrementally. Don’t ask it to rewrite your entire app. Start with one isolated module, verify it works, then move to the next.

So… Should You Care?

Look, I’m not switching from Claude entirely. For brainstorming and writing, Claude still feels more “human.” But for code? Gemini 3 is convincing me.

Deep Think’s plan-before-code approach is what I’d use it for, and the multimodality is genuinely useful (not gimmicky). The large context window for legacy code I haven’t tried on a real project yet.

My advice:

• Try it if you’re refactoring or chasing UI bugs from a video
• Stick with Claude/GPT-4 if you need creative writing or nuanced explanations
• Don’t trust it blindly: I’ve caught it suggesting bad practices when it’s outside its knowledge cutoff

The future of development is probably agentic. But we’re not there yet. Gemini 3 is a big step, though.

Related reading: more on letting AI take the first review pass: I tried using AI for code review on my side projects.

P.S. If you’ve tried Gemini 3, I’d love to hear what you think. Did it hallucinate component names for you too, or is that just me? Hit me up on LinkedIn.