This is a submission for the Google I/O Writing Challenge
"It's been 10 years since we pivoted the company to be AI first."
— Sundar Pichai, Google I/O 2026 Keynote, May 19, 2026
I watched the Google I/O 2026 keynote. And somewhere around the part where a Google DeepMind engineer named Varun Mohan demoed an AI agent that built a functioning operating system from scratch — in 12 hours — I kind of just... sat there staring at the screen.
Not because it was cool. I mean, it was cool. But because of what it quietly meant.
If agents can build operating systems, what does that say about my carefully maintained full-stack skill set? What does it say about yours?
Let me be honest with you. I'm a developer still learning, still grinding. I've spent time with HTML, CSS, JavaScript, Firebase, Supabase — the whole usual roadmap. And this I/O felt different from previous years. It wasn't just model benchmarks and capability updates. It felt like Google was quietly drawing a map — and the destination on that map is a world where AI agents don't help developers write code.
They are the developers.
And honestly? That question kept me up.
🗓️ What Actually Happened at I/O 2026 — The Short Version
Before I get into opinions, let's be clear on the facts. Google I/O 2026 ran May 19–20 at the Shoreline Amphitheatre in Mountain View, California. Over 7,000 people attended in person. The event was livestreamed to more than 500 developer events across 100 countries.
The big announcements, in order of "things that made my eye twitch":
| Announcement | What it is | Why it matters |
|---|---|---|
| Gemini 3.5 Flash | New flagship model for agentic workflows | Outperforms Gemini 3.1 Pro, runs 4x faster than competing frontier models |
| Antigravity 2.0 | Agent-first development desktop platform | Multiple autonomous AI agents working in parallel on your codebase |
| Antigravity CLI | Terminal version of Antigravity | Build and orchestrate agents without leaving your terminal |
| Antigravity SDK | Programmatic access to agent harness | Host custom agents on your own infrastructure |
| Managed Agents (Gemini API) | One API call = fully provisioned agent in isolated Linux sandbox | Infrastructure friction = gone |
| Google AI Studio updates | Native Kotlin support, Workspace integration, one-click Cloud Run deploy | Build and ship full-stack apps with a single prompt |
| WebMCP | Open web standard for browser-based AI agents | AI agents can directly interact with your web app's JS functions and HTML forms |
| Firebase → Agent-native | Firebase now integrates directly with AI Studio and Antigravity | Vibe-code full-stack apps, deploy to Cloud Run with one click |
| Gemini Omni | Multimodal world model — any input → any output | Videos, images, audio, text — all combined |
| Modern Web Guidance | Expert-vetted agent skills for web dev (100+ use cases) | Your agent knows web best practices |
| Migration Agent (Android Studio) | Migrates React Native/web/iOS to native Kotlin | Weeks of migration → hours |
| CodeMender | AI code security agent from Google DeepMind | Scans agent-generated code for vulnerabilities, auto-fixes |
🤖 The Part Nobody's Talking About: Antigravity Is Not a Coding Tool
Most people are framing Antigravity as "a better Copilot" or "Google's answer to Cursor."
That's wrong.
Antigravity — especially with the 2.0 update — is an agent orchestration runtime. There's a real difference. A coding tool suggests the next line. An agent runtime executes plans. It spins up subagents to work in parallel. It runs in the background. It connects to your Android builds, your Firebase project, your Cloud Run deployment. It does quality audits. It emulates user experiences. It even masks credentials automatically.
Google is trying to turn Gemini from a chatbot family into a distributed agent runtime. The center of gravity is not one product. It is the stack formed by Gemini 3.5 Flash, Antigravity, Gemini Spark, AI Mode in Search, Gemini Omni, Chrome, and developer-facing managed agents.
That's not a coding assistant. That's a software development lifecycle, automated.
💻 Let Me Show You What This Looks Like in Practice
Here's how Managed Agents actually work using the real Gemini Interactions API. This isn't pseudocode — this is the actual documented syntax from Google's official docs as of May 19, 2026.
Getting Started with Managed Agents (Real API Syntax)
Step 1: Install the SDK
Requires
@google/genaiversion 1.33.0 or later for Interactions API support.
npm install @google/genai
Step 2: Spin up a full agent with a single call
import { GoogleGenAI } from "@google/genai";
const client = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });
async function runManagedAgent() {
// One call = a fully provisioned Antigravity agent in a remote Linux sandbox
// The agent reasons, uses tools, executes code, and manages files autonomously
const interaction = await client.interactions.create(
{
agent: "antigravity-preview-05-2026", // The Antigravity base agent
input: `
Create a full REST API with Express.js that:
1. Has /users endpoint (GET, POST, DELETE)
2. Uses in-memory storage
3. Includes input validation
4. Writes unit tests with Jest
5. Creates a README.md
Run the tests and confirm they pass.
`,
environment: "remote", // Isolated Linux sandbox, hosted by Google
},
{ timeout: 300000 } // 5 min — agents take longer than a single prompt
);
// The agent doesn't just generate code — it runs it, fixes errors, returns results
console.log(interaction.outputText);
// Save these — you'll need them for the next turn
console.log("Interaction ID:", interaction.id);
console.log("Environment ID:", interaction.environmentId);
}
runManagedAgent();
Step 3: Continue the same session — files and state are still there
// Multi-turn: resume the exact same Linux environment
const followUp = await client.interactions.create(
{
agent: "antigravity-preview-05-2026",
input: "Now add JWT authentication to the existing API. Don't rewrite from scratch.",
// This is what makes it powerful — the previous environment persists
environment: interaction.environmentId, // Reuse the same sandbox
previousInteractionId: interaction.id, // Continue conversation history
},
{ timeout: 300000 }
);
console.log(followUp.outputText);
The agent doesn't forget. It picks up exactly where it left off — same files, same packages, same state. Like handing off to a developer who was already in the middle of the work.
⚠️ Note: Managed Agents / Interactions API is currently in preview. The API schema may change. For stable production work,
generateContentremains the recommended path — Google's own docs say so.
Modern Web Guidance — The Underrated Announcement
This is, in my opinion, the most slept-on announcement of I/O 2026. Nobody is talking about it enough.
# Install with one command — works with Antigravity or any agent
npx modern-web-guidance install
What this does: it gives your coding agent a set of 100+ expert-vetted web development skills. Not just "write valid HTML." We're talking WCAG accessibility standards, Core Web Vitals, security headers, Baseline API compatibility, progressive enhancement patterns.
Before this, your agent wrote working code. After this, your agent writes correct code.
That's not a nice-to-have. That's changing what "senior developer" actually means.
Firebase + AI Studio: Full-Stack App in One Prompt
// You type this in Google AI Studio:
"Build a task management app where users can:
- Sign in with Google
- Create and complete tasks stored in Firestore
- Get AI-powered task prioritization
- Deploy it live"
// What happens next (this is real, not a demo):
// ✅ Firebase project scaffolded with security rules
// ✅ Authentication configured via Firebase Auth
// ✅ Firestore schema and rules written
// ✅ Firebase AI Logic integrated for prioritization
// ✅ One-click deploy to Cloud Run (free tier for first 2 apps)
// ✅ Google Workspace APIs available via natural language
Firebase's integration with Google AI Studio now supports one-click deployment to Cloud Run — no billing required for your first two Firebase-enabled apps on the new Google Cloud Starter Tier. You can also connect your apps to Google Workspace data like Gmail, Docs, and Sheets using natural language, through a standard Firebase Auth "Sign in with Google" flow.
I tried this. It generated a working expense tracker — Firestore rules, authentication flow, and a functional UI — in about 4 minutes. Did I have to tweak things? Yes. A few field names, one security rule that was too permissive. But the scaffolding was solid. Faster than writing it myself? Embarrassingly, yes.
🤔 The Real Question: Are Developers Being Replaced?
Okay. Deep breath.
Let me tell you what I actually think — not the comfortable answer, not the "AI is just a tool" cope that shows up in every LinkedIn post.
Some developers are being replaced. Some are being upgraded. The difference is whether you understand what's happening.
The "Before" World (pre-2026)
- You write a feature → 2 days
- You debug a weird edge case → 3 hours
- You migrate an old codebase → weeks
- You write tests → almost as long as the feature
- You deploy → configuration hell
The "After" World (I/O 2026 and beyond)
- Feature → agent does it in 20 minutes
- Debug → agent finds it, fixes it, verifies the fix
- Migration → The Android Studio migration agent turns weeks into hours
- Tests → auto-generated and auto-run inside the sandbox
- Deploy → one click, Cloud Run
So yeah. Some of the work is being replaced. Specifically: the repetitive, formulaic parts.
But here's what ISN'T being replaced (yet):
- System design decisions — WHY you're building this architecture, not just HOW
- Understanding user needs — translating messy human requirements into precise specs
- Security judgment — knowing which tradeoff is acceptable and which isn't
- Domain context — what legal, ethical, business constraints apply
- Quality bar — recognizing when "working" ≠ "good enough to ship"
The agent doesn't know your company's security requirements. It doesn't know your users' edge cases. It doesn't know what scales to 1 million users. Yet is doing a lot of work in that sentence.
📊 Pros & Cons: Honest Assessment
✅ What's Actually Good
| What | Why |
|---|---|
| Gemini 3.5 Flash speed | 4x faster than competing frontier models — finally usable in real workflows |
| Managed Agents removing infrastructure | No more Docker config / VM setup just to run an agent |
| Firebase → Cloud Run one-click deploy | Free for first 2 apps. Removes the biggest full-stack friction point |
| WebMCP open standard | Web agents can be precise, not just "AI guessing at your DOM" |
| Migration Agent | Genuinely solves a real, painful, existing problem |
| Antigravity CLI | Terminal-first devs aren't second-class citizens |
| $2M XPRIZE Hackathon | Largest hackathon prize pool ever. A real opportunity. |
❌ What I'm Worried About
| Concern | Why |
|---|---|
| Forced Gemini CLI → Antigravity CLI migration | Google literally says "we encourage Gemini CLI users to migrate." Not a choice. |
| $100/month AI Ultra plan | Who gets access to frontier AI? Developers in Pakistan? India? Nigeria? The access gap is real. |
| Agent-generated code security | CodeMender catches vulnerabilities — but it's an agent checking another agent's code. Trust chains all the way down. |
| Total Google lock-in | AI Studio + Antigravity + Firebase + Cloud Run + Workspace. One ecosystem. Tightly coupled. What happens when pricing changes? |
| "Vibe coding" quality bar | Prompting a CRUD app ≠ building software that's maintainable in 2 years |
🔥 The Most Underrated Announcement: WebMCP
Everyone is talking about Gemini 3.5 Flash. Almost nobody is talking about WebMCP.
WebMCP is a proposed open web standard that allows developers to expose structured tools — like JavaScript functions and HTML forms — so browser-based AI agents can execute complex tasks with greater speed, reliability, and precision. The experimental WebMCP origin trial starts in Chrome 149, with Gemini in Chrome support coming soon.
Think about what this actually means.
Right now, AI agents interacting with the web are basically doing screen-scraping with extra steps. They're looking at raw HTML, guessing at intent, clicking things, and hoping it works. It's fragile. It breaks constantly.
WebMCP changes that architecture. Instead of the agent guessing at what your form does, you tell it. It's structured. Precise. Like giving AI a clean API to your website.
// WebMCP — based on proposed spec (origin trial in Chrome 149)
// Note: exact API surface may evolve as the standard matures
// In your web app, you expose capabilities to browser AI agents:
if ("webmcp" in navigator) {
navigator.webmcp.register({
tools: [
{
name: "create_task",
description: "Creates a new task in the project management system",
parameters: {
type: "object",
properties: {
title: { type: "string" },
priority: { type: "string", enum: ["low", "medium", "high"] },
dueDate: { type: "string", format: "date" },
},
required: ["title"],
},
handler: async (params) => {
// Your actual business logic here
return await taskAPI.create(params);
},
},
{
name: "get_user_tasks",
description: "Retrieves all tasks for the current user",
handler: async () => {
return await taskAPI.getForCurrentUser();
},
},
],
});
}
// Now a browser agent (Gemini in Chrome, etc.) can:
// "Create a high-priority task called 'Fix the login bug' due Friday"
// And it executes — precisely, through your API, not through DOM hacking.
This is the internet becoming agent-native. Not just a few Google apps — the whole web, if developers adopt it.
And the reason this matters for you as a web developer: the websites that expose WebMCP tools will work with AI agents. The ones that don't will be invisible to them. It's a new SEO, kind of. Except instead of optimizing for Google's crawler, you're optimizing for AI agents.
💬 What Sundar Pichai Actually Said — And What I Think He Meant
Pichai opened the keynote with: "It's been 10 years since we pivoted the company to be AI first."
On the surface, that's a corporate milestone statement. But underneath it, there's an implicit message:
The first 10 years were about building the AI. The next 10 years are about the AI building everything else.
Google's planned AI spending is expected to hit somewhere between $180 billion and $190 billion this year alone. That's not a bet. That's a complete restructuring of what the company is.
And for developers, that means the ground is moving under your feet whether you're watching the keynote or not.
🧪 My Honest Hands-On Experience
After the keynote, I actually tried things instead of just forming opinions in a vacuum:
1. Google AI Studio + Firebase
Built a simple expense tracker app via prompt. Firestore rules, auth flow, working UI — about 4 minutes. I had to edit the Firestore security rule for the user document (it was too open), and one of the UI components had hardcoded user IDs that needed replacing. But the scaffolding? Solid. The deploy to Cloud Run worked first try.
2. Modern Web Guidance
Ran npx modern-web-guidance install. It pulled in a large set of expert knowledge covering web performance, accessibility, and security. I then asked the agent to "make this page accessible." It identified missing alt text, added proper ARIA roles, and noted the color contrast ratio was below WCAG 2.2 AA standard. That's not a generic suggestion. That's specificity that usually requires a senior dev to catch.
3. Antigravity CLI (early preview)
Fast. The terminal experience is genuinely good. The credential masking is real — I tested it by deliberately putting an API key in a prompt and it masked it automatically. The agent ran terminal commands, checked output, and fixed its own mistakes mid-task. No manual intervention.
The honest verdict: it works. It's not magic. Agents still make dumb mistakes — wrong assumptions, over-eager refactors, occasional hallucinated package names. But the infrastructure is real. The speed is real. And it's moving faster than most developers are adjusting to.
📖 What This Means For Developers — The Uncomfortable Reflection
There are three kinds of developers right now:
Developer Type A — Sees AI agents and panics. Dismisses them as "hype." Keeps doing everything manually. Will be fine for a while. Then suddenly won't be.
Developer Type B — Sees AI agents and fully surrenders. Just prompts everything. Has no idea what the generated code actually does. Can't debug. Can't make architecture decisions. Produces fast, shallow work.
Developer Type C — Sees AI agents as force multipliers. Understands systems deeply. Uses agents for the mechanical work. Keeps judgment, architecture, and critical thinking in their own hands. This person becomes 10x more productive without becoming 10x more replaceable.
I/O 2026 forced me to ask: which one am I actually building toward?
Because Google didn't just release tools at this keynote. They released a vision. This is the era of agent-led development, where agents are evolving from coding assistants to intelligent collaborators capable of managing the entire software development lifecycle.
The entire lifecycle. Not part of it. All of it.
The only way to stay relevant in that world is to own the parts agents can't: judgment, context, taste, accountability. Those aren't soft skills. Those are the new technical skills.
🎯 What Should You Actually Do Right Now?
Stop consuming. Start building with the new tools. Here's a concrete list:
- Try the Antigravity base agent → antigravity.google — free tier available
-
Run a Managed Agent interaction →
npm install @google/genai@1.33.0+ the code above -
Install Modern Web Guidance →
npx modern-web-guidance install— immediate, free - Build one app in AI Studio with Firebase → aistudio.google.com — first 2 Cloud Run deploys free
- Read the WebMCP spec → developer.chrome.com/docs/ai/webmcp — origin trial, Chrome 149
- Apply for the XPRIZE Hackathon → geminixprize.com — $2M prize pool, September finals in LA
✅ Conclusion: The Map Has Changed
I'll leave you with this.
In 2016, Google said "AI first." Nobody really believed them, not fully.
In 2022, ChatGPT hit. People said "AI is a tool."
In 2024, agents started shipping. People said "it's not production-ready."
In 2026, at I/O, a Google engineer demoed an AI building an operating system in 12 hours. People in the audience laughed, nervously.
That nervous laugh is the sound of a mental model breaking.
We're not in the "AI assists developers" phase anymore. I/O 2026 was a clear pivot toward an agentic AI ecosystem where intelligent systems can assist users, automate workflows, and work across apps, devices, and services with minimal human intervention.
Minimal. Human. Intervention.
That's the destination Google put on the map at I/O 2026.
The question isn't whether you agree with the direction. It's whether you're building the skills that matter at the destination — or the skills that only mattered on the way there.
📚 References & Useful Links
| Resource | Link |
|---|---|
| 🎬 Google Keynote (May 19, 2026) | YouTube |
| 👩💻 Developer Keynote | YouTube |
| 🤖 What's New in Google AI | YouTube |
| 🔥 What's New in Firebase | YouTube |
| 💙 What's New in Flutter | YouTube |
| ☁️ Google Cloud Live from I/O | YouTube |
| Google Developers Blog — Dev Keynote Recap | developers.googleblog.com |
| Google Blog — Developer Highlights | blog.google |
| Introducing Managed Agents in the Gemini API | blog.google |
| Firebase I/O 2026 Announcements | firebase.blog |
| Official Antigravity Agent Docs | ai.google.dev |
| Gemini Interactions API Docs | ai.google.dev |
| WebMCP Origin Trial (Chrome 149) | developer.chrome.com |
| Modern Web Guidance | goo.gle/modern-web-guidance |
| Build with Gemini XPRIZE Hackathon | geminixprize.com |
| Google AI Studio | aistudio.google.com |
Written May 20, 2026 — the day after watching Google announce that an AI built an operating system in 12 hours, and feeling the very specific emotion of "excited and deeply unsettled at the same time."
Find Me Across the Web
- ✍️ Medium: @syedahmershah
- 💬 DEV.to: @syedahmershah
- 🧠 Hashnode: @syedahmershah
- 💻 GitHub: @ahmershahdev
- 🔗 LinkedIn: Syed Ahmer Shah
- 🧭 All links: Beacons
- 🌐 Portfolio: ahmershah.dev
Top comments (20)
Thanks for actually putting the real @google/genai syntax in here instead of just vague hype! Seeing the environmentId persistence in the multi-turn interaction example makes it click why this is a massive paradigm shift from standard stateless LLM wrappers. The fact that the sandbox state stays alive across API calls means the agent can actually engage in iterative debugging without you having to feed the entire file context back to it every single time. It's a massive win for token efficiency, even if it feels a bit eerie how human-like that workflow is.
Thanks, Faraz! Really glad that part resonated with you. You hit the nail on the head—the transition from stateless API wrappers to stateful, persistent environments is where "agents" stop being a buzzword and start being a practical tool. Saving those tokens on the context loop is a massive engineering win, even if that human-like iterative debugging feels a bit like sci-fi. Appreciate you reading and catching that detail! 👍🏻
Thanks for pasting the actual @google/genai syntax. Seeing environment: interaction.environmentId for multi-turn sessions really demystifies what "agent runtime" actually means compared to just another chat endpoint. The fact that the remote Linux sandbox state persists across API calls is a game changer. I do appreciate your warning at the end to stick to generateContent for stable production though—definitely saves some early adopters from a world of breaking-change pain!
Glad the syntax breakdown helped demystify it! Seeing the actual code makes it much clearer that we're dealing with stateful execution environments now, not just stateless text pipes. And yes, sticking to generateContent for production right now is highly recommended—building core business logic on experimental runtime states that are shifting week-to-week is a recipe for a 3 AM pager duty call. 👍
Honestly, the most satisfying part of this write-up was the shoutout to modern-web-guidance. Agents writing code that compiles is one thing, but an agent natively running checks against WCAG 2.2 AA standards and catching bad ARIA roles or color contrast ratios is insane. It takes a lot of senior-level discipline to catch those details consistently. If it can reliably automate the tedious compliance checking, I’m all for it.
It’s an incredible tool for catching the low-hanging fruit and the tedious syntax stuff that human devs often skip over. However, we still have to be cautious—while an agent can easily flag a missing ARIA label or bad contrast, it still can't truly "experience" the UX. We'll still need human judgment to ensure the actual flow makes sense for a real user using assistive technologies, but automating the baseline compliance is a huge step forward. 👍
That "Type B" vs "Type C" developer breakdown hit the nail on the head. "Vibe coding" an expense tracker in 4 minutes looks incredible in a demo, but if you don't know why a Firestore security rule is too permissive or how to spot hardcoded IDs in the generated code, you're just building technical debt at lightspeed. The real job going forward is clearly going to be system verification, design choices, and security judgment.
Exactly. The "vibe coding" phase feels like magic until you have to debug a race condition or a broken security rule that the AI hallucinated. Moving forward, the developers who thrive won't be the ones who can type code the fastest, but the ones who can look at 500 lines of generated architectural changes and instantly spot the security flaw or data leak. Code generation is cheap; system validation is priceless. 👍
Wait, a Firebase + Cloud Run starter tier with no billing required for the first two apps? Missed that during the livestream! For solo devs and hackers, that completely lowers the barrier to prototyping. Being able to scaffold a full auth and DB layer via AI Studio and launch it instantly without pulling out a credit card is a massive win, even if you have to manually tweak the schema afterward.
It definitely lowers the barrier, which is awesome for hackathons and solo devs. The catch to keep in mind, though, is the lock-in. Google makes it incredibly easy to scaffold this stuff for free because migrating off that specific AI Studio/Firebase architecture later, if your app scales or needs custom infrastructure, can be a real headache. It's a great win, but with strings attached! 👍
Quality breakdown, Syed. The distinction you made between Developer Type B (the prompt-and-pray crowd) and Type C is incredibly important. It reminds me of when high-level languages first came out and assembly devs thought the sky was falling. The "mechanical" part of coding is absolutely being commoditized by things like Antigravity, but the hardest part of software engineering has never actually been typing out the syntax—it’s figure out what to build and why, while navigating messy human requirements. If an agent can handle the scaffolding in 4 minutes, that just means we have to step up our game on system architecture and product thinking.
That assembly analogy is spot on, Vicky. History definitely repeats itself whenever the abstraction layer moves up. I do think there’s a slight catch, though—while product thinking and architecture become the new baseline, the sheer volume of generated code means debugging and code review might actually get harder, not easier. We won't just be architects; we'll have to be incredibly sharp code auditors to make sure those 4-minute scaffolds don't inherit hidden architectural debt. 👍
Is anyone else deeply terrified by the total Google ecosystem lock-in you pointed out? Antigravity + Firebase + Cloud Run + AI Studio... it feels like they’re building a beautiful, frictionless golden cage. The moment your entire deployment pipeline, agent orchestrator, and codebase are completely intertwined in one proprietary runtime, switching costs become practically infinite. If Google decides to jack up the price of that $100/mo Ultra plan or change the Cloud Run starter tier rules in two years, a lot of "vibe coders" are going to find themselves stranded without a backup plan.
You are completely right to call out the "golden cage," Zohaib. The lock-in is real, and the switching costs for a fully integrated Antigravity/Firebase pipeline will be brutal. However, playing devil's advocate: for a solo dev or a fast-moving startup, that frictionless ecosystem might be the only way to compete on speed right now. The real challenge will be designing codebases with clean abstraction layers so that the core business logic isn't completely tied to proprietary runtimes—though as you said, "vibe coders" probably won't realize that until the invoice hits. 👍
That nervous laugh from the audience you mentioned really hits home. I’ve been feeling that exact same cognitive dissonance while watching the I/O coverage. It’s wild to think that we’ve gone from "AI can write a regex for you" to "AI just provisioned a Linux sandbox and built a microservice while you fetched coffee." The section on WebMCP is what really caught my eye, though—treating AI agents as a first-class citizen in the browser DOM completely flips how we think about semantic HTML and SEO. It’s no longer just about being readable to a crawler; we’re literally building APIs for autonomous users. Brilliant write-up, thanks for articulating the existential dread so clearly!
"Building APIs for autonomous users" is a perfect way to frame it, Sahil. That cognitive dissonance is exactly what inspired the post. The only nuance I’d add to the WebMCP/SEO shift is that while it flips semantic HTML on its head, it might also create a massive web scraping arms race. If every site becomes perfectly machine-readable for agents, protecting intellectual property and data ownership is going to get incredibly messy for creators and businesses. It’s an exciting boundary, but a legal minefield. 👍
As someone who practically lives in Neovim, I was incredibly relieved to see you call out the Antigravity CLI and the forced migration from the old Gemini CLI. Google pushing everyone toward an agent-orchestration terminal runtime instead of just a standard autocomplete wrapper is a massive shift. The auto-credential masking you mentioned is a killer feature, though—I can't tell you how many times I've accidentally leaked a test key in a local prompt session.
Fellow Neovim user! It’s great to hear that resonated. The credential masking is a lifesaver, but we do have to be careful not to let it make us complacent about environment security in our local dotfiles. As for the shift to an agent-orchestration terminal runtime, it's a massive adjustment, but keeping control of the local environment within our existing terminal workflows is going to be the saving grace for power users. 👍
That section on WebMCP just gave me chills, and not the good kind. Everyone is losing their minds over Gemini 3.5 Flash, but structured browser tools for agents feel like a massive paradigm shift. It’s wild to think that we might soon be optimizing our frontends for Chrome 149 origin trials instead of standard SEO. If a site is invisible to an agent because it lacks WebMCP registration, it’s basically dead in the water. Absolutely fascinating (and terrifying) point.
It really is a double-edged sword. While optimizing for the "Agent Web" opens up wild new distribution channels, the thought of the open web being gated by proprietary origin trials and strict machine-readable registrations is deeply concerning. If we aren't careful, it could centralize web traffic even further into the hands of whichever browser runtimes control the dominant agents. It’s a fascinating, high-stakes shift we all need to watch closely. 👍