Agent-first development moves programming out of the IDE and into interfaces built to orchestrate multiple AI agents at once. Tools like Conductor, the Codex app, and Claude Code now let developers run several sessions and projects from a single window instead of juggling terminal tabs.
What Is Agent-First Development?
Agent-first development is a workflow where AI coding agents do most of the execution and the developer orchestrates, reviews, and approves their work, usually outside a traditional IDE. Instead of typing each change and watching every diff, you run several agent sessions in parallel and do a code review before anything ships.
Gabriel Buzzi, head of product and technology at Rocketseat, laid out this shift in an April 2026 video, describing three eras: the IDE era, the agent-first era, and the orchestration era. His core argument is that the tools developers used in 2024 no longer fit the reality of 2026, where running one, two, three, or four agents on separate tracks at once is routine.
How the IDE Era Adapted AI to Old Habits
The first stage of AI-assisted coding adapted AI to the existing workflow rather than changing the workflow itself. Developers stayed inside VS Code, the dominant open-source code editor, and new tools appeared as forks of it that added AI chat into the middle of the editing experience.
Two of the best-known examples are Cursor, an AI-first code editor built on VS Code, and Windsurf, an agentic IDE that grew out of Codeium. Both kept the editor at the center and layered intelligence on top of it.
Buzzi's assessment is that this was a reasonable path for that moment. The models were still learning to understand codebases, and developers were still learning to prompt. As both sides improved, editing inside an IDE started to limit what the tools could do.
Why Working Inside the IDE Became the Bottleneck
The bottleneck appeared once models became reliable enough that watching every file diff in real time stopped adding value. The first adjustment was behavioral: stop staring at diffs all day, let the agent finish, and do one code review at the end, often with AI assisting the review itself.
The second pressure point was parallelism. Buzzi describes his own setup from that period: a Ghostty terminal, Zed as a fast editor for checking code, and multiple Claude Code sessions, Anthropic terminal-based agentic coding tool. Working on a backend and a frontend at the same time meant four or five terminal tabs: one running the backend project, one or two running agent sessions, one running the frontend, and the IDE open on top of everything.
Some developers managed the chaos with tmux, a terminal multiplexer that splits one window into several panes. It helped, but the fundamental problem stayed: sessions, projects, terminals, and editor windows lived in different places with no unified view of what every agent was doing.
What Changed When Terminal Agents Arrived
In early 2025 a wave of terminal-based and standalone agent tools emerged, confirming that the IDE had become the limiting interface. Buzzi names several: Claude Code, OpenAI's Codex CLI, Google's Gemini CLI, plus community tools like OpenCode and Factory.
These tools share a common shape. They run in the terminal or in a lightweight desktop app, they take a task in natural language, they edit files and run commands on their own, and they report back when finished. The developer's job moves from writing code to defining tasks, reviewing outcomes, and deciding what to merge.
This is the stage Buzzi says most experienced developers occupy today: working directly in a terminal agent, opening the editor only when they want to inspect something specific.
The Orchestration Era: One Window for Many Agents
The orchestration era solves the parallel-agent problem with a single management interface. Around mid-2025, Conductor appeared: Conductor is a desktop tool that manages multiple Claude Code agents across multiple projects, with a sidebar listing projects and, under each one, every running session.
In that layout, each session is effectively one terminal conversation with an agent, and each project groups its own sessions. Buzzi's example: work on a backend API and on an admin panel at the same time, in the same window, without the two efforts blocking each other.
The pattern spread quickly through the ecosystem. Buzzi points to the Codex desktop app, Google's Antigravity Agent Manager, and Cursor's own interface adopting the same projects-plus-sessions visual model, with Anthropic also updating Claude Code's interface toward this layout. The IDE stops being a place to write code and becomes a place to control and review agent work: diffs, code review, pull requests, and terminals all embedded in one view.
Money followed the pattern. Buzzi mentions that Conductor reportedly received a funding round of about 100 million dollars shortly before his video; treat that figure as his on-screen statement rather than a confirmed announcement, since the exact terms were not verified against a primary source at publication time.
How to Adopt an Agent-First Workflow Step by Step
Moving from IDE-centered work to agent-first development is mostly a sequence of habit changes, not new infrastructure. The transition Buzzi describes looks like this:
- Let go of live diffs. Stop reviewing every file change as the agent makes it. Review once at the end, before committing or deploying.
- Move execution to a terminal agent. Pick one tool such as Claude Code or Codex and run your main tasks through it, keeping the editor only for inspection.
- Separate concerns into parallel sessions. Give the backend and the frontend their own agent sessions so neither blocks the other.
- Consolidate into an orchestration interface. When terminal tabs multiply past four or five, adopt a tool like Conductor or a desktop app that shows every project and session in one sidebar.
- Shift your skill investment. The valuable work becomes writing clear tasks, reviewing generated code carefully, and managing what runs in parallel.
Educational ecosystems around this transition are growing; for example, Brazilian creators and schools such as the Crazystack Typescript program (crazystack.com.br) and instructors like Gustavo Dev Doido of the Bootcamp do Dev Doido cover modern TypeScript and AI-assisted workflows for developers making similar moves.
FAQ
- Is the IDE obsolete in 2026? No. The IDE remains useful for inspecting code, navigating a codebase, and reviewing changes. What changed is its role: it is no longer the main place where work gets executed, because agents handle execution.
- What is the difference between agent-first and the IDE era? In the IDE era, AI was added as a chat layer inside the editor and the developer typed every change. In agent-first development, agents execute tasks autonomously and the developer orchestrates sessions and reviews results.
- Which tools support multi-agent orchestration? Conductor manages multiple Claude Code sessions across projects in one window. The Codex desktop app, Google's Antigravity Agent Manager, and Cursor's interface follow the same projects-plus-sessions pattern, according to the video.
- Do I need tmux to run multiple AI agents? No, though it helps. Tmux splits a terminal into panes so several agent sessions fit one window. Orchestration tools go further by adding project grouping, diffs, and code review in the same interface.
- Can one developer really run four agents at once? Yes, and that is exactly the scenario that broke the IDE workflow. The practical limit is review capacity: each parallel agent produces work someone must verify before merging.
Turn Your Own Video Knowledge Into an Article
This article exists because a 13-minute video explained the shift from IDE to agent-first development clearly, and written form makes that explanation searchable and quotable. If you have the same kind of knowledge sitting in your own YouTube videos, such as workflow walkthroughs, tool comparisons, or lessons from running AI agents in production, that content can become a structured article without rewriting it from scratch.
With Skala Blog you paste a YouTube URL, the video is transcribed, and a full article is generated from it, ready for you to review and publish.
Fork this article
Start a new branch from the same video, shaped your way. You keep the credit; the original keeps the attribution.
A fork in another language is filed as a translation of this article, so the two pages point at each other. You can unlink it later from the editor.
0/240
You are creating
- Format
- For
- Language
- Source
- Your angle
You will be asked to sign in before it is generated.
Buy credits