Elvis Li's Portfolio

Let’s be real: I don’t care about AI smart glasses, and I definitely don’t care about a chatbot that can write a heartwarming poem about Kubernetes. When I’m deep in a refactoring session at 2 AM, squinting at a broken asynchronous data pipeline, I care about exactly one thing: Can this model write clean, production-ready code without hallucinating a non-existent npm package?

Google just dropped its latest Gemini upgrades at I/O 2026, and they are plastering benchmarks everywhere claiming it blows previous generations out of the water. But as developers, we’ve been burned by marketing teams cooking the evaluation metrics too many times.

So let's strip away the fluff. No omni-channel marketing talk. No background lifestyle agents. We are looking strictly at raw coding capability. How does the new Gemini 3.5 Flash stack up against our current daily drivers: Anthropic’s Claude (the developer sweetheart) and OpenAI’s latest GPT-5.5 ecosystem?

Grab your coffee. Here is the unfiltered ground truth.

The Terminal-Bench Showdown

If you want to know if a model can actually function as an engineer rather than a glorified copy-paste assistant, you stop looking at HumanEval. Those tests are basically just LeetCode puzzles the models memorized during training. Instead, you look at agentic coding benchmarks like Terminal-Bench 2.1 and the MCP (Model Context Protocol) Atlas.

These tests don't just ask the model to write an isolated function; they throw it into a simulated Linux sandbox, hand it a broken repo, and say: "Fix the integration tests."

Here is how the big three actually score right now:

The Beyoncé Rule of developer tools applies here: If you liked your context window, then you should have put a flawless retrieval architecture on it.

Google’s supremacy isn't just that Gemini 3.5 Flash hit 76.2% on Terminal-Bench. It’s that it did it while pushing output speeds four times faster than other frontier models. When you are running iterative test-and-repair loops inside a CLI, latency is the difference between staying in the zone and losing your mind waiting for a response.

Spin Up an Isolated Execution Loop

Google didn't just launch a model; they added Managed Agents directly into the Gemini API. Instead of you writing endless boilerplate loops to parse an LLM's text output, extract the code block, run it in a local docker container, and feed the error back, Google abstracts the entire execution environment into a single API call.

It’s dead simple to spin up an isolated, stateful environment where the model can write and test its own scripts:

import { GoogleGenAI } from '@google/genai';

// Initialize the Gemini 3.5 client
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

// Provision an isolated Linux sandbox that maintains state 
// across multiple turns without losing variables or context
const codingSession = await ai.agents.create({
  model: 'gemini-3.5-flash',
  instructions: 'Refactor our legacy database migration scripts from CommonJS to ES Modules.',
  tools: [
    { type: 'code_interpreter' }, // Native execution environment
    { type: 'file_system_sandbox' }
  ],
  sandbox: {
    environment: 'node-20',
    hardenedPolicies: true // Prevents rogue scripts from infinite looping
  }
});

console.log(`Sandbox live: Session ${codingSession.id}. Ready to crush tech debt.`);

⚠️ Pro-tip: While Gemini 3.5 Flash is terrifyingly fast at running these internal loops, do not give any agent raw, unmasked access to production environment variables inside these execution sandboxes. If the model accidentally pulls an external dependency that contains a malicious exploit, a compromised sandbox becomes a compliance and maintenance nightmare.

The Deep Dive: Abstract Syntax Trees vs. High-Velocity Context

To understand why you would choose one model over another for programming, you have to understand the fundamental difference in how these architectures handle logic.

Anthropic: The Structural Pedant

Anthropic’s Claude (especially through Claude Code) treats your codebase like an Abstract Syntax Tree (AST). It is hyper-analytical about variable scopes, structural side effects, and type safety.

If you give Claude a massive TypeScript monorepo, it excels at trace analysis—figuring out exactly why changing an interface on line 42 of a user service breaks a consumer layout three folders over. It is slow, deliberate, and incredibly precise.

Gemini 3.5 Flash: The Contextual Speed Demon

Google didn't build Gemini 3.5 Flash to be a slow, academic thinker. They tuned it for high-velocity agentic loops. Because it has a massive 1-million-token context window paired with a highly optimized inference engine, its strategy is brute-force speed combined with broad situational awareness.

Instead of meticulously calculating the AST impact of a change before typing, Gemini 3.5 Flash can read the entire codebase, spin up a sub-agent, compile the project, look at the compiler errors, and rewrite the file in the time it takes Claude to finish its initial planning phase. It treats programming as an empirical loop: write, run, fail, fix, repeat.

The Bottom Line

Here’s the deal. We are past the point where one model dominates every single aspect of software engineering. Stop looking for a single silver bullet and route your tasks based on reality:

Stick with Anthropic when you are doing deep architectural refactoring, complex logic design, or writing hyper-strict type definitions where a single logical error will cause a cascade of runtime failures. Claude remains the king of pedantic correctness.
Switch to Gemini 3.5 Flash the second you are dealing with massive codebases that exceed standard 128K/200K context windows, or when you are building autonomous automation pipelines (like automated dependency updates, CI/CD log parsing, or writing scripts that require rapid trial-and-error execution).