JetBrains Air: The IDE That Doesn't Require Coding Has Arrived

JetBrains has made its move.

The company that has dominated the Java, Kotlin, and Python developer toolchain for nearly two decades has just released something completely different from its IntelliJ series — Air. It’s not yet another AI‑assisted IDE; it’s a product that’s fundamentally different at its core: you don’t write code, you write task descriptions, then watch AI do the work.

JetBrains calls it an ADE (Agentic Development Environment). Note, not an IDE. The name itself is a signal: they believe the core work of developers is shifting from “writing” to “orchestrating and reviewing.”

In one sentence: what is Air?

The traditional IDE workflow is: you write code → compile → debug → commit.
Air’s workflow is: you describe a task → the AI Agent plans and executes → you review the result → accept or reject.

Sounds like Cursor, Windsurf, or Devin? Superficially yes, but JetBrains is approaching it differently.

Core design: Task as a first‑class citizen

Air’s entire interaction model is built around “Tasks.” These aren’t casual chat‑window prompts, but well‑defined work units with a clear lifecycle:

• User describes the requirement in natural language
• Agent analyzes context and creates an execution plan
• Task runs in an isolated environment (local workspace, Git worktree, Docker container, and soon cloud containers)
• Once execution completes, it enters the review phase
• User decides whether to accept, modify, or reject

The keyword is “isolation.” Each task runs in its own environment, without polluting your main branch. This solves a major pain point of existing AI coding tools — when AI modifies multiple files and breaks something, rollback costs are high. Air’s model is closer to code review: the Agent submits a “change set for review” rather than writing directly into your codebase.

Multi‑Agent concurrency: where the real differentiation begins

Most AI coding tools today are single‑threaded — you issue one command, wait for completion, then the next. Air supports multiple Agents working in parallel.

Meaning? You can have three tasks running simultaneously:

1. One Agent refactoring the user authentication module
2. Another writing unit tests
3. A third fixing a CSS layout bug

Each works independently in its own Git worktree, with no interference. You act like a tech lead — allocating tasks, monitoring progress, and reviewing output.

This design philosophy is fascinating. Air isn’t simulating “a faster programmer,” but “a small dev team.” JetBrains clearly believes the bottleneck in AI coding isn’t generation quality (that’s model‑level) — it’s how efficiently to schedule and manage multiple concurrent AI workflows.

Working with Junie CLI

Released alongside Air is Junie CLI, JetBrains’ command‑line AI Agent tool. If Air is the graphical orchestration center, Junie CLI is the execution unit for CI/CD pipelines.

Their relationship is similar to GitHub’s Web interface vs. gh CLI — same capabilities, different contexts. You can iteratively debug task descriptions in Air, then, once refined, drop the same prompt templates into Junie CLI for automated runs.

This means JetBrains’ ambition goes beyond “assisted coding.” They aim to cover the entire chain — from development to deployment.

Air’s position among competitors

The AI‑coding field is already crowded. A quick comparison:

| Product | Positioning | Key Differentiator | |----------|--------------|--------------------| | Cursor | AI‑native code editor | VS Code‑based, focuses on inline editing | | Windsurf | AI IDE | Cascade multi‑step reasoning, strong context handling | | Devin | Autonomous AI engineer | Fully automated, minimal human input | | GitHub Copilot Workspace | Task‑driven development | Deeply integrated into GitHub ecosystem | | JetBrains Air | Agentic Development Environment | Multi‑Agent concurrency + isolated execution + JetBrains toolchain |

My assessment: Air’s true advantage isn’t in raw AI capability (everyone uses similar models), but in two areas —

First, JetBrains’ deep understanding of code semantics. After twenty years of expertise in static analysis, refactoring engines, and type inference, they have immense strength in “understanding code structure.” This directly affects how well Agents build context. A tool that can precisely find “where this function is invoked” provides far better context to AI than one that only does text search.

Second, enterprise developer trust. Many IntelliJ users are backend teams from finance, telecom, and large internet companies — all with strict requirements for code security, auditability, and access control. Air’s task isolation + review mechanism naturally fits those environments. In contrast, Devin’s “fully automated” route faces more adoption friction in enterprise settings.

Details worth noting

From what’s publicly known, several aspects stand out:

Flexible execution environments. Tasks can run in a local workspace, Git worktree, Docker container, or cloud container (upcoming). This lets you choose isolation based on risk level — edit minor text in a local worktree, refactor core modules inside Docker.

Not locked to one model. JetBrains’ recent AI strategy (Junie already supports multiple backends) suggests Air won’t be tied to a single LLM. That’s good for developers — you can pick the most suitable model per task: use Claude for system design, GPT for quick code gen, DeepSeek for reasoning‑heavy tasks. With aggregator services like OpenAI Hub, model switching becomes nearly frictionless.

Review experience is make‑or‑break. Generating code with AI is easy; reviewing AI‑generated code is hard. If Air’s review interface is just a standard diff view, it’ll feel no different from “AI submits a PR for you to review.” JetBrains must enhance review support — e.g., auto‑annotate “this change affects these downstream calls”, “this refactor preserves behavioral equivalence.” This plays directly into JetBrains’ strengths, though details are still scarce.

What does this mean for developers?

Honestly, ADE as a category is still nascent. Air has just launched; maturity and real experience remain to be seen.

But the direction is clear: developers are evolving from “direct code producers” to “designers and reviewers of AI workflows.” This doesn’t mean coding skills are less important — quite the opposite. You’ll need stronger code‑reading, architectural judgment, and systems thinking to effectively review AI output.

An interesting analogy: Air vs. traditional IDEs is like Kubernetes vs. manual deployment. You don’t manipulate the underlying details directly; you declare the desired state and let the system implement it. But you must understand the underlying mechanics — otherwise, debugging becomes impossible.

For teams, some questions to ponder:

• Does your codebase have sufficient documentation and type annotations for AI Agents to understand context?
• Is your CI/CD pipeline robust enough to mitigate risks from AI‑generated code?
• Do your code review processes need adjustments to handle the “human reviews AI‑written code” scenario?

These aren’t Air‑specific but general challenges of the AI‑coding era. Air’s release simply makes them more urgent.

Final thoughts

JetBrains launching Air is a statement in itself. This is a company sustaining thousands of employees by selling IDE licenses — now building a product that might make traditional IDEs less central. Either they see an unavoidable shift coming, or they want to lead the change. Most likely, both.

Product site: air.dev — feel free to check it out. It’s still early; my suggestion is to watch the space and wait for community feedback before investing time to learn it.

---

References

• Linux.do community discussion: JetBrains releases a new tool Air — early developer discussion and shared resources on Air