Hands-On Air with Dmitry Jemerov and Grigorii Kargin
In a Nutshell
Dmitry Jemerov and Grigorii Kargin demonstrate JetBrains Air, a new agentic development environment that runs AI agents (Anthropic, OpenAI, Google, Juni) in isolated workspaces or Docker containers while retaining IDE navigation and search features for code review. The core workflow centers on plan mode for complex tasks, agent-generated code review by a second agent, and worktrees for parallel development, with the team stressing that reviewing AI-generated code remains essential for maintainable projects. Air is currently Mac-only with Windows/Linux and ACP support planned for May, positioning it as the preferred tool when agents handle 80% of coding versus traditional IDEs for manual editing.
These notes were generated by AI and may contain inaccuracies.
Dimitri hosts the live stream with Grigori Kargin, team lead of Air at JetBrains. Grigori has worked at JetBrains on multiple IDEs and previously on Kotlin. He is currently studying linguistics at the University of Leiden and has been working on a linguistic database project. He is exploring JetBrains' AI development tools.
Grigori explains that Air is an agentic development environment centered around agent experiences. It is agent agnostic and supports agents from Anthropic, OpenAI, Google, and JetBrains' own agent Juni. ACP support is planned to allow any ACP-compatible agent.
The installation is performed through Toolbox. Air is currently available on Mac, with Windows and Linux internal builds ready and planned for release in May. ACP support will appear in the nearest build under a feature flag, with full marketplace support coming.
Users can use multiple subscriptions simultaneously, including JetBrains AI, OpenAI, and Anthropic keys. This allows using both cloud agents and local agents together.
Air presents an onboarding walkthrough. Environment options include local workspace, Git worktree, and Docker. Local workspace uses the main copy of the project, while Docker provides isolation for running multiple application instances without conflicts.
Reviewing AI-generated code is emphasized as essential. For code that will persist in a project, understanding the structure prevents confusion when issues arise. This differs from one-off scripts where review may be optional.
The linguistic database project contains:
- A model package with framework-independent Kotlin code implementing core logic including languages and rules
- A Spring Boot web application providing a REST API over the model
- A Next.js and TypeScript frontend
Air focuses on agent-driven workflows and omits extensive manual editing support. Navigation, browsing, and searching features are retained because they help developers understand project context and review agent-generated results effectively. Test running is expected to be handled by agents through the terminal rather than dedicated test runners.
Claude.md is initialized using Opus. The generated file provides guidance for the linguistic data storage tool including repository layout and common commands. The file is deleted since it is not part of the actual project.
The backend runs first, followed by the frontend. The application displays a language database containing information about multiple languages, with Old English selected for dictionary component work.
The first task requests implementation of filtering by part of speech, accessible both on the backend and frontend. The requirement includes updating the URL when filtering by specific part of speech. Codex is selected for this task, and plan mode is reserved for later, more complex work.
Air filters the view to show only changes from the current task session. This applies to both local sessions on the same source copy and Docker-based work.
Navigation includes:
- Shift+Shift for file navigation by name
- Command+O for go-to actions
- Usages view for reviewing code context
Supported languages include Kotlin, Python, TypeScript, Rust, Go, and JavaScript. Java support is planned or recently added. The keymap can be switched to IntelliJ-style shortcuts.
A separate agent review task can be initiated via a dedicated button. This creates a subtask where another agent reads generated code and leaves inline comments. Different agents can be configured for generation versus review through settings, allowing Codex for generation and Claude for review, for example.
The generated part-of-speech selector correctly filters verbs. The URL updates when selecting a part of speech when opened in a regular browser, confirming the frontend routing works as intended. The layout places the selector at the top of the page as requested.
New tasks can be started in parallel using worktrees. Air automatically sets up worktrees when creating new tasks via the plus button.
The linguistic database tracks inflected forms of words including case forms and definite article embeddings, plus attestation locations in texts. Currently, attestations are not linked to specific inflected forms. The goal is to display attestations next to each inflected form on the word page rather than as a global list. This requires both frontend and backend changes.
Plan mode is selected for this task to allow review before implementation. The task is planned locally first.
Comments left during review can be sent back to the agent for fixes. The agent suggests corrections including proper handling of part-of-speech values that match neither language-defined lists nor existing words, and fixing URL construction that incorrectly concatenates query parameters.
Approximately half of the Air team uses AI almost full-time for development, while some team members remain skeptical and prefer traditional approaches. Codex is commonly used on the Air codebase itself.
Dmitry explains his shift in priorities: while he loves writing code and has worked as a developer for many years, for this particular project he values the project's existence more than the enjoyment of the coding process. The project fulfills an actual need in the linguistic community, and there's extensive work required to build it into something practical linguists can use. He notes having papers to write alongside the code, which makes AI assistance valuable for productivity.
For the model itself, Dmitry still values code quality significantly. However, for the front end, he acknowledges his limited expertise - he's not a senior front end developer. The REST API contains substantial boilerplate, with non-boilerplate parts needing refactoring to move logic into the model. The architectural goal is having all logic reside in the model, independent of REST APIs, making it testable and tested. This would make the Spring Boot component auto-generatable.
Grigorii discusses finding a balance between maintaining a clean core application while allowing features to be written more iteratively with less initial care. Once features prove valuable, they can be cleaned up through review and refactoring.
The team discusses using Claude versus Codex for generating plans, noting Claude produces more readable plans. They describe a phenomenon they call "denial of service" - when a very small prompt generates an excessively large amount of text that becomes difficult to track. They mention storing plans in a specific location and marking files accordingly.
When switching agents, the system remembers user preferences for specific models. The team notes the importance of consistent model selection across tasks.
The team launches a work tree workspace for implementing the plan, noting it's a different environment and copy of sources. Work trees are task-based, with some tasks sharing workspaces while others have separate ones. An icon indicates work tree status versus local tasks.
Reviewing changes generated by the agent for the specific task, they note occasional race conditions and false positives in the detection system. The agent made changes to "words by letter" which was apparently incorrect. They close unrelated files and open the current task.
The agent asks meaningful questions during implementation. One question concerns whether to keep a filter block when the global data station is removed, so data stations not related to infected forms remain visible next to the main form. Dmitry confirms he wants to keep the filter block.
Dmitry describes the typical experience of working with agents as constantly switching between different tasks. The agent extracts language for the dictionary and identifies parts of speech, though the purpose of certain actions isn't always clear.
The system requests approval for bash commands during implementation. After approval, the work tree task proceeds. Keyboard shortcuts include Command-2 and Command-1 for various panel operations.
The team discusses access sandbox protection - if the agent operates outside the directory, it shouldn't cause issues. They note the challenge of agents losing state during operations.
Dmitry commits changes and emphasizes the importance of Git integration quality. The interface differs from familiar tools but remains usable. He inquires about the status of other running tasks.
The implementing task runs lint and encounters build issues because the work tree doesn't copy node_modules. Scripts exist to set up work trees in advance. The team compares the Claude-generated plan with the actual implementation.
The plan generated by Claude wasn't detected properly in the interface. The work tree task completes and becomes ready for review. The implementation includes a detection generator substation model.
The working copy lacks a copy of the data, making it difficult to test the new functionality during the stream. Dmitry plans to review it after the stream.
Grigorii requested showing a quick preview of the web version. The team demonstrates launching a new task and notes that cloud runs are available in the app. They're working on the web version and team availability features, though still in early development.
Air is written in 100% Kotlin, enabling porting to WebAssembly. The browser version runs Kotlin code compiled with the Kotlin to WebAssembly compiler. It relies on garbage collection support in WebAssembly, which became possible only recently. This may be the largest project in WebAssembly currently.
The web version presents the exact same Air user interface as the desktop application, running completely in the browser on a remote cloud machine.
Addressing questions about relying on Air for real development tasks during public preview: the team acknowledges bugs exist but emphasizes ongoing quality work. They use it internally and encourage trying it for both pet projects and work tasks.
Dmitry compares Air's preview status to using nightly IntelliJ IDEA builds throughout his career. The worst case scenario with a code editor is closing it and using a previous build. However, he notes that state compatibility issues can occur when rolling back versions.
If users rely on agents for 80% of workflows, Air would be a better fit. If users spend 80% of time writing code manually, traditional IDEs remain more convenient. One advantage of Air is its fluent 60 FPS UI rendering throughout, built on a custom UI framework, providing noticeable responsiveness compared to Electron-based tools like VS Code.
Choosing between Air and CLI tools depends on personal preference and user expertise level. For users who don't spend much time configuring CLIs or building custom pipelines, Air offers advantages including an integrated development environment for efficient code browsing and usage searching. Dmitry identifies as an IDE person throughout his career, having used Visual C++, Delphi, and IntelliJ.
The team draws a parallel between coding tool evolution (CLI editors like Vim to GUI IDEs) and agent tool development, noting major vendors focusing on desktop tools over CLIs.
Previously, a custom bash tool rendered inside Air's terminal had performance overhead, leading to temporary disablement in favor of native bash tools. The goal is fixing the custom tool's performance to restore it. Conceptually, there should be no difference since the same agent code runs behind the scenes.
For open source agents, the team knows bash tool implementations, but for agents without published source code like cloud agents, they can't verify implementation details. Different prompts might affect quality. Currently, vanilla bash tools are used for all agent harnesses.
The team discusses Vim mode support, noting their focus isn't primarily on code editing. However, they acknowledge some users need it for navigation and are accustomed to it. Users can upvote the feature request on YouTrack.
Cloud subscription usage isn't supported due to Anthropic's terms of service. Custom APIs like Azure Bedrock aren't currently supported but are in the backlog. ACP (Agent Client Protocol) support is prioritized first.
Juni, another JetBrains product, is already integrated with Air. Users can select Juni when opening new tasks. Juni supports all major models.
Air migrated to Kotlin Multiplatform and is almost running on Compose using an internal fork. The plan is switching to vanilla Compose runtime. ACP support is targeted for May, with Windows and Linux support coming soon.
Cloud containers are being provided to design partner companies for collaboration. General availability is expected late Q2 to early Q3. The team hopes this aligns with Air leaving public preview status.
ACP (Agent Client Protocol) is a predefined interaction format. Before widespread adoption, custom adapters were needed for specific CLI agents. With ACP support, integration becomes easier as it's a standardized protocol.
ACP provides rich interactions beyond simple CLI tool execution, including knowing where diffs are and when agents ask questions, enabling users to see and respond to agent queries easily.
The team reviews contest submissions showcasing AI-assisted development successes:
- Jack Jackson: Created accurate verified reports for campus use despite funding limitations
- Fall Rick: AI helped write an animation system, though debugging took 12 hours
- Raphael Stolt: Created complete PHP package with unit tests using ChatGPT 4.5 in 1.5 hours
- Egbert Jan Voorle: AI created Python script updating translation XML files, reducing days of work to 3 minutes
- Nick Cosmo: Built Telegram bot that processes receipt photos and automatically writes expense rows to Google Sheets
- Maria Ciortea: AI created 80K lines of React mobile app code for product specification and enhancement
- Luigi: Used agent through Teamocil for production debugging with permission flows requiring approval for each command and data access
The last code will go to Set Jackson 1143.
Dmitry Jemerov will drop his email in the YouTube chat. Viewers should write an email to contact him directly, and he will provide the promo code.
Dmitry Jemerov thanked the audience for their attention and expressed that the session was very interesting for him personally. He hopes the session was interesting for viewers as well. He thanked Gregory for his great help in exploring the product.
Keep JetBrains in your library
Save the videos and channels worth coming back to, and find them again in one place.
