This is a submission for the Google I/O 2026 Writing Challenge
I took notes during Google I/O the way I take notes during any conference — obsessively, out of order, with a lot of question marks.
What follows isn't a summary. Summaries flatten everything to equal importance, and not everything announced this week has equal importance. This is closer to a field guide: what I noticed, what I tested, what confused me, and what I think is actually worth your time.
I'll be specific where I can. Where I'm speculating, I'll say so.
The context window is real. The reasoning is not automatically better.
Gemini's 2 million token context window is not a marketing number. I fed it a full production codebase — about 180,000 tokens of actual working code, not a demo project — and it didn't choke. It loaded. It answered questions about files I hadn't mentioned.
Here's the problem: big context and good reasoning are not the same thing.
I asked it to find the source of an intermittent bug. It gave me a confident, detailed, structurally convincing answer. The answer was wrong. Not slightly wrong — completely fabricated. It invented a race condition that matched the symptom description so well that I spent 40 minutes verifying it before accepting that the race condition didn't exist.
The actual bug was a missing await in a file I hadn't explicitly mentioned.
Long context makes hallucinations harder to catch, not less frequent. The model has more material to build a plausible-sounding wrong answer from. Keep that in mind before you dump your entire monorepo into the prompt.
Practical note: Use long context for retrieval-style questions ("does this codebase have any usage of X?") not for debugging or reasoning tasks. The former works well. The latter is a confidence trap.
Agents went from demo toy to something I'd actually deploy
I've been skeptical of "AI agents" since the phrase entered the hype cycle. Most implementations I've seen are just chains of API calls with a marketing layer on top.
The Gemini agent demos at I/O this year were different in one concrete way: error recovery.
Previous agent demos I've watched fail gracefully — they stop, report the error, wait for a human. These ones rerouted. Not always correctly, but they rerouted. The agent assigned to pull data from a malformed JSON endpoint didn't quit — it tried a fallback, logged why, and continued with partial data.
That's the behavior that makes agents actually useful in production. Not perfect execution. Graceful degradation.
I haven't run this on my own infrastructure yet. The session I'm watching is the What's New in Google AI stream from May 19. I'll update this after I test it on a real task this week.
Google AI Studio: the tool the developer relations team isn't talking about enough
Everyone covered the Gemini API features. Almost nobody covered the quality-of-life changes to AI Studio itself.
Session persistence. This is the one that changed how I work. AI Studio now holds context between turns in a way that feels stateful — you can leave a session, come back, ask a tangentially unrelated question, return to the original task, and it still knows what you were building. I don't know if this is a context management trick or something deeper in the session architecture. What I know is that I stopped having to paste my component spec back into the chat every time I changed tabs.
Side-by-side diff view. When you ask it to revise code, it now shows you what changed instead of just the full rewrite. Obvious feature in hindsight. Surprisingly rare before now.
Direct API export. You can take any successful Studio session and export it as a curl command, Python snippet, or Node.js call with one click. Sounds small. Cuts about 15 minutes out of every "ok this worked in Studio, now how do I reproduce it in my app" workflow.
Firebase security rules + Gemini: the announcement I'm watching most carefully
Firebase security rules are where junior devs make expensive mistakes and senior devs still have to be careful. The rules syntax is specific, the failure modes are security holes that don't announce themselves, and the feedback loop is terrible — you write rules, deploy, and find out months later that a path was too permissive.
Google announced Gemini integration that can analyze your rules against your data model and flag mismatches.
I haven't tested this. I want to test this. My hesitation is that "AI reads your security rules" could mean one of two things:
- It does a pattern check against known antipatterns (useful, limited)
- It actually understands the relationship between your schema and your rules and flags the specific path where a user could read someone else's data (very useful, hard to build) I'll find out next week on a project where the rules have been making me nervous for two months.
The thing nobody's calling out: Google is betting on the API layer
Read the I/O announcements as a product person, not a developer, and something becomes clear: Google is not trying to win the UI layer. Gemini isn't competing with ChatGPT for consumer mindshare as its primary goal. The goal is the API and infrastructure layer — the part that sits underneath every product you build.
AI Studio, Firebase integration, Vertex AI updates, the Gemini API in Android Studio — these are all targeting the developer who is building something else and needs AI infrastructure underneath it.
This is smart for Google and slightly uncomfortable if you're a startup building AI-native tools on top of Google's APIs. The infrastructure provider and the application layer are getting closer together.
Not saying it's bad. Just worth knowing when you're making architectural decisions.
What I'm actually going to use this week
In order of how likely I am to get to it:
- AI Studio with session persistence — replacing my current workflow of pasting context into every new conversation
- Long-context code review — specifically for retrieval questions, not reasoning. "Find all places where we're not handling the error case in async functions."
- Firebase rules analysis — one real project, one set of rules I've been nervous about
- Gemini 1.5 Pro API — I have a document processing task that's been barely within the 1M token limit. 2M gives me room. I'm skipping the agent stuff for now. Not because it's uninteresting — because the agent architecture I'd want to use it in doesn't exist yet in my stack. That's a me problem, not a Google problem.
The honest summary
Google I/O 2026 was a solid developer conference with a few genuinely useful announcements buried under a lot of infrastructure noise that only matters if you're running things at scale.
The useful stuff: AI Studio improvements, the actual behavior of agent error recovery, the Firebase rules analysis if it's as deep as the demo implied.
The stuff I'll check back on in six months: the 2M token context window for reasoning tasks (I expect the model quality to improve, not just the window size), and anything involving on-device Gemini Nano — interesting in theory, and I've been burned enough times by "on-device AI" claims to wait for real-world latency numbers.
If you want to watch the sessions yourself: the Google I/O session explorer has everything. The Gemini API session and the What's New in Google AI keynote are the two I'd start with if you're a developer who doesn't have six hours.
I'll update this post after I test the Firebase rules integration. Probably Thursday.
If you spotted something in the sessions I missed, drop it in the comments — I'm specifically curious if anyone tested the on-device Gemini features on non-Pixel hardware.