JetBrains launches AI agent IDE built on the corpse of abandoned Fleet

How to Ship Real Software with JetBrains Air: A Vibe Coding Guide for Agentic Development

JetBrains Air lets you delegate tasks to multiple AI agents that run concurrently in isolated environments (local workspace, Git worktree, Docker, or soon cloud containers) using a lightweight editor built on the Fleet codebase.

The announcement is significant because JetBrains has officially retired the standalone Fleet IDE (downloads ended December 22, 2025) and repurposed its technology into Air — an agentic development environment designed for the new reality where AI does more of the heavy lifting. Instead of one assistant chatting in your IDE sidebar, you now orchestrate multiple specialized agents that work in parallel, review output, and require human approval before changes land.

This unlocks a completely different workflow: you stop writing every line yourself and start acting as a conductor for AI agents. Loyal IntelliJ users may wonder what’s in it for them (Air is currently a separate product), but for anyone comfortable editing code and using AI coding tools, Air represents a practical way to move from “vibe coding” to shipping production-grade features faster and more safely.

When to use JetBrains Air

Use Air when you:

• Want to break a complex feature into parallel sub-tasks (frontend, backend, tests, documentation)
• Need safe sandboxes for agents to experiment without polluting your main codebase
• Are comfortable reviewing and approving AI-generated changes before they merge
• Want to use a vendor-neutral protocol (ACP) so you’re not locked into one model provider
• Are building internal tools, prototypes, or greenfield web/mobile apps where speed matters more than deep IDE refactoring support

It is less suitable right now if your team lives entirely inside IntelliJ IDEA, works on huge monorepos with complex build setups, or needs local/open-source models (Ollama support is planned but has no ETA).

The full process: From idea to shipped feature using Air

1. Define the goal (10 minutes)

Start with a crisp one-sentence outcome.

Bad: “Make a todo app” Good: “Build a responsive web todo application with user authentication, real-time sync using Supabase, and end-to-end tests, ready for deployment on Vercel.”

Write this goal at the top of a new task in Air. This becomes the North Star that every agent references.

2. Shape the spec and break it into parallel tasks

Air shines when you create multiple concurrent tasks. Create a main “Project Orchestrator” task and then spawn child tasks:

• Task 1: Project Setup & Architecture
• Task 2: Authentication & Database Schema
• Task 3: Frontend UI + State Management
• Task 4: API Layer & Real-time Sync
• Task 5: Testing & CI Workflow
• Task 6: Documentation & Deployment

Starter prompt template you can copy into Air:

Goal: {{your one-sentence goal}}

Create a complete production-ready {{technology stack}} implementation with:
- Clean architecture (explain your folder structure)
- Proper error handling and loading states
- Accessibility and responsive design
- Comprehensive test coverage (unit + integration)
- Environment variable strategy for local/prod
- Deployment configuration for {{platform}}

Work in a new Git worktree or Docker environment so we can review changes safely.
Output:
1. Step-by-step plan
2. File tree
3. Exact commands to run
4. Any decisions that need my approval

3. Scaffold the workspace

In Air, create a new task and choose the execution environment:

• Git worktree — best for most cases (isolated branch, easy to merge later)
• Docker — when you need a completely clean environment with specific runtimes
• Local workspace — only for very small changes

Use the built-in editor or connect your preferred editor via the Agent Client Protocol (ACP). The preview currently runs best on macOS; Windows and Linux versions are coming.

4. Implement with multiple concurrent agents

This is where Air feels different. Launch several agents at once:

• One agent works on the Supabase schema and auth setup
• Another scaffolds the Next.js 15 app with Tailwind and shadcn/ui
• A third writes the test suite in parallel

Switch between tasks in the Air interface to review progress. Agents can run concurrently because they operate in isolated execution contexts.

Practical prompt refinement technique:

After the first agent responds, feed its output into the next agent:

Here is the database schema created by the previous agent:
{paste schema}

Now implement the API routes that use this exact schema. Follow the same conventions for error handling and TypeScript types.

5. Validate and approve changes

Air’s strength is the review step. For every task:

• Review the proposed file changes in the diff view
• Run the provided commands in the integrated terminal
• Test functionality manually or via the generated test suite
• Ask the agent to fix issues by creating a follow-up task: “The login flow fails with CORS error. Fix it and explain what changed.”

Only approve and merge when you are confident. Treat agent output with the same scrutiny you would a pull request from a junior developer.

6. Ship safely

Once all tasks are green:

1. Merge the Git worktree into your main branch
2. Run full test suite locally
3. Push and trigger CI
4. Deploy to staging
5. Smoke test in production-like environment
6. Merge to main and deploy

Copy-paste prompts (starter templates)

Architecture decision prompt:

We are building {{app name}}. Compare these two approaches:
1. {{Option A}}
2. {{Option B}}

Recommend one. Explain tradeoffs for developer experience, performance, and maintenance. Then generate the initial file structure and key files for the chosen approach.

Bug fix prompt:

The following error occurs: {{error message}}

Here is the relevant code:
{{code}}

Reproduce the issue if possible, then fix it. Provide before/after diff and explain the root cause.

Pitfalls and guardrails

What if the agent hallucinates a non-existent API?

Always ask the agent to show you the exact external documentation or source it is relying on. If it cannot, force it to use only APIs that exist in the current dependencies. Air makes this easier because you can run commands and see real output.

What if agents conflict because they edit the same files?

Use separate tasks with clear ownership. Example: “Frontend agent is not allowed to modify any files in the /api or /lib/server directories.” Reinforce this boundary in every prompt.

What if the output is low quality?

Be extremely specific about quality standards in the initial prompt. Include phrases like “Follow React Server Components best practices”, “Use TypeScript strict mode with no any types”, or “Write tests using Vitest with 90%+ coverage”.

What if I’m worried about sending proprietary code to cloud models?

Air supports bring-your-own-key. For sensitive codebases, wait for local model support or use it only for non-sensitive greenfield projects. JetBrains has stated local models (Ollama/Qwen) are an active planning item.

What if I’m an IntelliJ power user?

Treat Air as a specialized workshop for new features or side projects rather than a full replacement. You can still use IntelliJ for deep refactoring and use Air to generate initial implementations that you then open in your main IDE.

What to do next

After shipping your first feature with Air:

• Create a reusable “Project Kickoff” task template with your preferred stack
• Document your approval checklist so other team members can review agent work
• Experiment with chaining agents (output of one becomes input of another)
• Measure time saved vs traditional vibe coding — track one feature built both ways
• Give feedback to JetBrains on the public preview (especially missing local model support and Windows/Linux availability)

Air is still in public preview. The macOS version is available now. Expect rapid iteration as JetBrains incorporates feedback.

The era of agentic development is here. Tools like JetBrains Air give you a practical, review-driven way to stay in control while multiplying your output. The builders who master orchestrating multiple agents — rather than just prompting one chatbot — will ship faster in 2026 and beyond.

Sources

• JetBrains Air: agentic development environment in preview (Techzine Global)
• JetBrains launches AI agent IDE built on the corpse of abandoned Fleet (The Register, March 10 2026)
• The Future of Fleet (JetBrains official blog, December 2025)
• JetBrains abandons Fleet IDE, pins hopes on forthcoming Air agentic development tool (DevClass)
• JetBrains is mothballing its Fleet IDE service (IT Pro)

This guide was written for developers who already know how to code and want a repeatable process for turning AI announcements into shipped software.