This is a submission for the Google I/O Writing Challenge

Everyone walked away from Google I/O 2026 talking about Gemini 3.5 Flash benchmarks. Veo 3. Gemini Omni doing multimodal physics. The usual keynote sugar rush. Good stuff. Expected.

But if you want to understand why this I/O actually changes how developers build — not in theory, in production, this week — you need to look at something that got maybe four sentences in the developer keynote.

A markdown file called SKILL.md.

I didn't read about this. I ran it. Here's what actually happened.

What Antigravity CLI Actually Creates (Not What the Slides Said)

Every I/O recap I've read describes AGENTS.md as the agent configuration primitive. Clean. Simple. One file.

That's not quite right. Here's what /agents shows in a fresh Antigravity CLI 1.0.2 session on a real project:

Create New Agents
  Workspace: C:/Users/sreej/Downloads/Projects/SoilSense AI/.agents/agents/{agent_name}/agent.json
  Global:    C:\Users\sreej\.gemini\antigravity-cli\agents\{agent_name}\agent.json

▼ Available Agents
  • /default   Default agent

Agent definitions are JSON, not markdown. The markdown lives one level down — in skills:

Skills  
129 skills

Create new skills
  Workspace: ~/Downloads/Projects/SoilSense AI/.agents/skills/{skill_name}/SKILL.md
  Global:    ~/.gemini/antigravity-cli/skills/{skill_name}/SKILL.md
  Shared:    ~/.gemini/skills/{skill_name}/SKILL.md

So the actual structure is:

your-project/
└── .agents/
    ├── agents/
    │   └── {agent_name}/
    │       └── agent.json      ← agent behavior (JSON)
    └── skills/
        └── {skill_name}/
            └── SKILL.md        ← reusable capabilities (markdown)

And Antigravity ships with 129 built-in skills already — everything from agency-agentic-search-optimizer to agency-code-reviewer. You're not starting from zero. You're extending a library.

That's not a minor correction. That's a different mental model from what the keynote implied.

I Tested It on a Real Project

I ran this on SoilSense AI — a Capacitor/Android app with an existing codebase, git history, and a src/ directory full of React components. Not a demo project. A real one.

One prompt:

create a skill for SoilSense AI that reviews any new component 
for accessibility issues before committing

What followed was not autocomplete. The agent:

1. Read package.json to understand the stack
2. Scanned src/, src/lib/, docs/PROJECT_STRUCTURE.md
3. Checked ListPermissions — confirmed read/write access
4. Ran git status to understand current state
5. Proposed a hybrid approach and asked for approval before proceeding

The plan it proposed:

• A global AI agent skill (soilsense-accessibility-reviewer) — a SKILL.md that instructs the agent to audit git-staged components using LLM-level reasoning
• A standalone Python checker (check-a11y.py) for static WCAG rule enforcement
• A pre-commit git hook that blocks commits containing critical violations

I typed proceed. Here's what it built:

Create(~/.gemini/config/skills/soilsense-accessibility-reviewer/SKILL.md)
Create(~/.gemini/config/skills/soilsense-accessibility-reviewer/scripts/check_a11y.py)
Create(SoilSense AI/scripts/check-a11y.py)
Create(SoilSense AI/.git/hooks/pre-commit)

Then — without me asking — it created a mock broken component with intentional violations, staged it, and ran the hook against itself to verify.

Result:

5 Critical issues detected:
  - Missing alt tags
  - Custom clickable divs lacking tabIndex/onKeyDown handlers  
  - Empty button
  - Unlabeled form inputs

3 Warnings:
  - Redundant alt terms
  - Positive tabIndex anti-patterns
  - Unlabelled decorative SVG/Lucide icons

→ Commit blocked. Fix critical issues or use --no-verify to bypass.

It caught real violations, blocked the commit, displayed results in a console table, then cleaned up the mock component and reset git state. The pre-commit hook is now active in the SoilSense AI repo.

One prompt. No orchestration code. No config files written by hand.

That's the thing nobody is explaining in I/O coverage: the skill file didn't just change what the agent knows — it changed what the agent does to your repository.

The Gemini CLI Retirement Nobody Is Explaining Clearly

Here's the detail buried in the Antigravity 2.0 announcement: Gemini CLI shuts down for consumer tiers on June 18, 2026. That's not optional. Free tier, AI Pro, AI Ultra — same message for all.

What you're migrating to:

The multi-model routing is worth pausing on. Antigravity CLI supports Claude and GPT-OSS models through the same interface — you're not locked to Gemini at the CLI layer. The Managed Agents API is Gemini 3.5 Flash specifically, but locally you have model choice.

The last row is the one I keep thinking about. Gemini CLI was open source. Tens of thousands of contributors, forks, extensions built on it. Antigravity is closed. Google is moving developer tooling into its monetization stack and calling it an upgrade. That's accurate. It's also incomplete.

What the 129 Built-In Skills Actually Signal

When /skills showed 129 built-in skills, I scrolled through them. A few that caught my eye:

• agency-agentic-search-optimizer — audits whether AI agents can actually accomplish tasks on your site (WebMCP readiness)
• agency-ai-data-remediation-engineer — self-healing data pipelines using air-gapped local SLMs
• agency-autonomous-optimization-architect — shadow-tests APIs for performance while enforcing financial constraints
• agency-codebase-onboarding-engineer — helps new engineers understand unfamiliar codebases

These aren't autocomplete improvements. They're behaviors — things the agent will do autonomously when invoked. The skill file is the instruction set. The agent is the executor.

The accessibility reviewer I built for SoilSense AI is now skill number 130. It lives at ~/.gemini/config/skills/soilsense-accessibility-reviewer/SKILL.md. Every future Antigravity session in that project can invoke it.

That's the primitive. Not a feature. A composable unit of agent behavior that lives in version control.

Where I'd Push Back

A few things I'm not ready to be hyped about.

The closed-source problem is real. Gemini CLI being open source meant the community could audit the tool that had file system access to their codebases. Antigravity is closed. The pre-commit hook it created runs code from ~/.gemini/config/skills/ — a path Google controls the contents of at install time. For personal projects, fine. For anything enterprise, you need answers about what the agent runtime can and can't do with your code before you're committed.

proceed is doing a lot of work. The agent asked for approval before executing. I typed proceed without reading the full implementation plan. It created files in four locations, modified git hooks, and ran git commit against a real repository. The workflow assumes you'll review the plan carefully. In practice, under deadline pressure, most developers won't. That's a governance problem, not a technical one — but it's the kind of thing that causes incidents.

Skill scope creep is easy. The accessibility reviewer skill is global — it lives in ~/.gemini/config/skills/, not in the SoilSense AI project directory. That means it's available in every Antigravity session across every project on this machine. That's convenient. It's also how you end up with 60 global skills that conflict with each other in ways that are hard to debug. Antigravity's skill priority system (Workspace → Global → Shared) handles this, but you have to know it exists.

Getting Started (Windows, since that's what I actually used)

# Download from https://antigravity.google.com/download
# Or via winget (if available in your region)
winget install Google.AntigravityCLI

# Navigate to your project
cd "C:\Users\you\Projects\your-project"

# Launch
agy

# Inside the shell — explore what's available
/skills    # See 129 built-in skills + any you've created
/agents    # See available agents (just /default to start)

# Create your first skill with a plain English prompt
# Example: "create a skill that enforces our API response schema before any PR"

Start with /skills before writing anything. There's a good chance what you want already exists in the 129 built-ins. The skill creator workflow (plain English → agent builds SKILL.md + supporting scripts + tests) is the fastest path to something that actually runs.

The Real Take

Google didn't ship a better autocomplete at I/O 2026. They shipped a runtime for agent behavior — and gave you a text file as the configuration interface.

One prompt to Antigravity CLI created a WCAG accessibility reviewer, a Python static analysis engine, a git pre-commit hook, and a self-verification test — for a real Android/Capacitor project I'm actually building. The commit hook is active right now. It will block the next accessibility violation before it hits the repo.

The Gemini 3.5 Flash benchmarks will be obsolete in six months. A skill file that enforces your team's standards on every commit — that compounds.

The platform is impressive. The 130th skill is what makes it real.

What would you build as your first custom skill — a linter rule, a PR description generator, or something specific to your stack? Especially curious if anyone has gotten workspace-scoped skills working alongside the global ones without conflicts.