Google I/O 2026 made agentic development look exciting. Building with it made me realize something stranger.

I started building a multi-agent system with Antigravity 2.0 the same day I finished watching the Google I/O 2026 announcements.

At first, it felt unreal.

I would describe a milestone, and the system would start generating structure almost immediately:

implementation plans
milestone breakdowns
architecture files
backend scaffolding
routing
service layers

For a while, it honestly felt like cheating.

But after a few hours, something started bothering me.

Not because Antigravity 2.0 was bad.
The opposite, actually.

It was too agentic.

The Difference Between Watching Code and Touching It

Before Antigravity 2.0, I had used earlier Antigravity workflows built closer to a traditional editor experience.

I could open multiple files comfortably.
Inspect generated code directly.
Edit things manually while the AI worked beside me.

That mattered more than I realized.

Antigravity 2.0 felt optimized for orchestration instead of close supervision. The workflow was heavily conversational and agent-driven. I spent most of my time prompting, reviewing outputs, and approving changes while the system generated files rapidly in the background.

Technically, the experience was impressive.

Emotionally, I started feeling strangely disconnected from the project.

The faster the workflow became, the less attached I felt to the architecture itself.

I wasn’t really building anymore.

I was directing.

Then I Found Antigravity IDE

While researching the new ecosystem, I realized Google had split Antigravity into multiple workflows:

Antigravity 2.0
Antigravity CLI
Antigravity SDK
Antigravity IDE

The moment I discovered Antigravity IDE, everything suddenly made sense to me.

This was the environment I actually wanted.

AI-assisted development, but still close to the code.
Still tactile.
Still editable.

As a developer, I don’t just want generated output. I want visibility. I want to open five files side-by-side, inspect logic manually, trace decisions, and intervene whenever something feels wrong.

So I switched immediately.

That’s when things went sideways.

My Files Survived. My Project Context Didn’t.

The codebase still existed.

But the conversation history from Antigravity 2.0 was gone.

Worse, several generated planning artifacts disappeared too:

implementation-plan.md
milestone planning files
workflow notes
architecture reasoning

I had already progressed through roughly two milestones of the project. Only about a day of work, technically.

But it didn’t feel small.

Because the missing pieces weren’t just files.

They were reasoning.

At first I felt annoyed.

Then frustrated.

Then genuinely panicked.

I opened parts of the project and realized I couldn’t fully explain why certain structures existed anymore. Some of the architecture decisions had happened conversationally inside the agent workflow itself.

And that was the moment the entire Google I/O keynote suddenly became real to me.

The most important part of my project wasn’t living entirely inside the repository anymore.

Part of it was living inside the conversation.

The Strange Fragility of Agentic Development

That realization stuck with me more than any benchmark or demo from I/O.

Because in traditional development, source code is usually the source of truth.

If you have the repository, you have the project.

But agentic workflows quietly change that assumption.

The prompts contain planning.
The chats contain implementation reasoning.
The generated milestones contain architectural context.
The agent history contains rejected approaches and debugging decisions.

The code survives.

The understanding may not.

And honestly, I don’t think most developers have fully processed this shift yet.

We are getting very good at preserving generated output.

We are still terrible at preserving generated reasoning.

Antigravity IDE Actually Made Me Appreciate This More

Ironically, switching to Antigravity IDE made me appreciate the future of AI-assisted development more, not less.

Because it restored something important:
developer proximity.

I could inspect files directly again.
Edit architecture manually.
Stay connected to the implementation while still benefiting from agentic workflows.

That balance matters.

I don’t think the future is “developers manually writing everything forever.”

After using these systems, that future is obviously gone.

But I also don’t think developers want to become passive supervisors watching autonomous systems generate software from a distance.

The best workflows will probably be the ones that combine:

agentic speed
conversational intelligence
and deep human visibility into the code itself

Not just autonomy for the sake of autonomy.

We Need Version Control for Reasoning

Google I/O 2026 convinced me that software development is becoming increasingly conversational.

Not metaphorically.

Operationally.

And I think future developer tooling will eventually need to treat reasoning as part of the project itself:

conversational memory
implementation context
architectural discussions
milestone planning
agent decisions

Not as disposable chat history.

As infrastructure.

Because for the first time in my life, I opened a working project and still felt like part of it was missing.

And that feeling changed how I think about AI-assisted development completely.