Intent: The IDE That Doesn’t Show Code

Augment, the AI-native IDE company, just released Intent — and it’s a radical rethink of what an IDE should be.

There’s no code editor.

No file browser. No syntax highlighting. No tabs. No “Open in Terminal” button. The entire interface is built around one core loop:

  1. Write a spec (your intent)
  2. Agents orchestrate and execute
  3. Verify the results

That’s it. You never look at code. The machine does.

This is the endpoint of a conversation that’s been building all year. Phillip Su argued that AI agents killed the IC role. I wrote about the validation gap — how decision-making without immediate feedback feels empty.

Intent solves it by removing the decision point entirely. You’re not writing code. You’re not even looking at code. You’re orchestrating agents to build things from spec.

What Intent actually does

From what I can see on the landing page:

Living specs. Specs auto-update as agents complete work. Requirements change → updates propagate to all active agents. No more “what did we decide?” because the spec is the source of truth and it maintains itself.

Agent orchestration. A Coordinator agent breaks down your spec into tasks. Specialist agents execute in parallel. A Verifier checks results against the spec. The Coordinator keeps them aligned.

One unified window. Built-in browser for previewing. Git integration for commits and branches. No context switching between IDE, terminal, and browser.

Resumable sessions. Close it, come back tomorrow, everything’s where you left it. Auto-commit captures work as it completes.

The product design is honest about what’s happened: coding is no longer the bottleneck. Decisions are. Specification is. Orchestration is. The UI reflects that ruthlessly.

What this means

Intent isn’t trying to help you code better. It’s trying to help you not code at all.

This is different from Copilot or Claude Code or any other LLM IDE extension. Those products still assume the human is the primary actor and the agent is a helper. Intent inverts it: the agent is the primary actor, and the human is the orchestrator.

You’re not writing code. You’re writing intent. You’re not debugging. You’re verifying. You’re not learning how the system works by building it — you’re learning whether your decisions about the system were right.

This is the living endpoint of Su’s “IC is dead” argument. Su said the IC role transforms into manager-work because that’s what maximizes agent productivity. Intent takes that logic all the way: if the IC role is manager-work, why have an IDE at all? Why have a code editor? Just give them a spec window and orchestration controls.

The validation loop closes differently

Remember the core problem I identified: when you make architecture decisions through agents, you lose the immediate feedback loop. You can’t measure if you’re right until weeks later.

Intent’s answer: make that the entire product. Don’t try to hide the latency. Lean into it. The spec is the contract. Agents build to spec. Verification proves whether the contract was right.

This is actually elegant. Instead of flying blind on whether your decisions were good, you have:

  • A permanent, executable artifact (the spec)
  • Agent teams working toward it (coordinator + specialists + verifier)
  • Proof of success (verification against spec)

It’s like unit testing for architecture decisions. You write the test (spec), agents build the thing, the test passes or fails.

For someone like me, who’s been bothered by the validation gap, this is… actually interesting. Not just validation, but automated validation. The spec is the test. Pass or fail.

The cost

There’s an obvious tradeoff: you lose the accidental learning that comes from implementation.

When you build code yourself, you learn the language, the framework, the idioms. You hit edge cases that teach you how systems work. You sit in the debugger and develop intuition.

With Intent, you write specs. Agents build. You verify. Zero line-of-code learning.

Su would say that’s fine — you’re no longer an IC, you’re an orchestrator. Your job is to write better specs, make better architectural decisions, verify smarter. The learning shifts to decision-making, not implementation.

But there’s a real skill gap here. Writing specs is harder than writing code. It requires you to think clearly about what you want before the agent builds it. Most developers spend their careers learning to think through code. Spec-first thinking is a different muscle.

Intent is betting that forcing that shift is good. Spec-first + agent execution + verification is a better way to build than code-first + manual implementation.

Maybe it’s right. Or maybe it’s like asking a pianist to conduct an orchestra. Different skills entirely.

What this means for you

If Intent works as advertised, we’re watching the IDE die in real time.

Not in the sense of “IDEs will disappear.” In the sense of “the IDE as a code editor is obsolete.” The core value of an IDE was being a good place to write code. If agents do the writing, that value disappears.

Intent’s replacement: a spec orchestration platform. You specify intent, agents execute, you verify and iterate. The whole flywheel is spec ↔ agent ↔ verification.

This accelerates everything Su predicted. If you’re building anything more complex than a script with agents, your job isn’t coding. It’s:

  • Writing precise specs
  • Orchestrating agent teams
  • Verifying results
  • Iterating on intent

Learn those skills. Because Intent suggests they’re not optional anymore. They’re the job.

The real question

The question isn’t whether Intent will succeed as a product. The question is whether it’s right that the IC role transforms completely.

I think it might be. But I also think the first generation of Intent-style developers are going to be the unlucky ones — learning spec-first thinking the hard way, while the generation after them just grows up expecting specs as the primary artifact.

If you’re building with agents today, you’re in that unlucky generation. Might as well lean into it deliberately.

This continues the series on building with AI agents: where did the learning go, two approaches to analytics, and the human in the loop. Intent represents the product endpoint of this transformation.