Loading…
Jetbrains
Software development company that builds smart programming tools, especially integrated development environments (IDEs), to help developers write and fix code efficiently
- 94 posts summarised
- latest
The Good Stuff
Paid picks we use ourselves. Links carry a referral code — a subscription through one earns us a commission at no extra cost to you.
From their blog
Latest articles
Your Next Action Is Two Dots Away
IntelliJ IDEA’s command completion, triggered by typing .. in the editor, provides context-aware access to IDE functionality without memorizing shortcuts or navigating menus. The feature analyzes the syntax tree, scope, and caret position to present only relevant actions. In the 2026.3 EAP, logpoints are now accessible through command completion, and the IDE can suggest replacing print statements with logpoints. AI actions such as explaining code, generating docstrings, and refactoring are also available through the same .. workflow. Postfix completion and live templates now share a consistent interface with command completion, and support extends to binary files, decompiled code, properties files, and Spring workflows.
Our Framework for Reviewing AI-Generated Code
JetBrains Research, in collaboration with Lund University, studied how to review AI-generated code as AI agents produce thousands of lines across multiple files quickly. The core problem identified is trust calibration: developers cannot gauge an LLM’s confidence per line, making line-by-line review unscalable. The study proposes a three-level conceptual framework: overview for high-level hypotheses, file-level risk stratification, and code snippet-level chunk decomposition with chain-of-thought linkage. This framework was developed through participatory design with 17 practitioners and a follow-up survey of 43 professionals, and will be presented at ESEIW 2026. The paper argues that current diff viewers are inadequate for AI-generated code and that tools must surface risk and confidence signals at the granularity where developers allocate attention.
Java and Kotlin by IntelliJ IDEA: The LSP-Based Extension Reaches Release Candidate
JetBrains announced that Java and Kotlin by IntelliJ IDEA, an LSP-based extension, has reached Release Candidate stage. The extension brings IntelliJ IDEA’s Java and Kotlin language intelligence to third-party editors like VS Code and Cursor. Since the preview, it has been downloaded over 20,000 times and includes features such as smart code completion, navigation, inspections, quick-fixes, project-wide refactorings, DAP-based debugging, Maven, Gradle, and Bazel project support, built-in test running, and Spring tooling interoperability. The RC is the final EAP build and will be available for 30 days without a license; after the stable release, a 30-day free trial will be offered, then an IntelliJ IDEA Ultimate subscription is required. The extension also makes its intelligence available to coding agents in Cursor, enabling semantic code search and analysis.
Content and Community Basics for JetBrains Content Creators
The post covers community-building basics for JetBrains Content Creators in a golden age of digital creation with high demand and AI adoption, accepting new creators daily. Creators should include the JetBrains promotional discount code in video descriptions, with an example offering 20% off for new and existing subscriptions, and they can explore all JetBrains IDEs through the All Products Pack to diversify their workflow. Maintaining active social media is essential for distribution, and the program supplies news-worthy items like merch drops and IDE updates for creators to share with their audience. Staying in touch through communication, challenges, and giveaways is crucial, and the program provides up to twelve free IDE subscriptions per creator for giveaways. Even a simple subscription plus repost formula works effectively, and all new creators are welcome to join the program.
JetBrains Joins the Open Source Security Foundation
JetBrains has joined the Open Source Security Foundation (OpenSSF) as a general member. OpenSSF is a cross-industry Linux Foundation initiative that works to secure the software supply chain, hosting projects like Sigstore for signing and SLSA for supply chain integrity, and its AI/ML Security Working Group publishes guidance on signing ML models and safe instructions for AI code assistants. The foundation announced the membership at OpenSSF Community Day Europe in Prague. JetBrains cites the rise of coding agents and AI as creating new security challenges, making it more important for developers to understand and verify code and dependencies, and notes that its own product JetBrains Air addresses these questions. The company aims to collaborate with the industry through OpenSSF to help shape the future of secure software development, as stated by Katherine Druckman, Head of Community and Partnership Engagement.
dotInsights | October 2026
The dotInsights newsletter from JetBrains collects recent .NET and software development articles for developers. Topics include C# 15 collection expression arguments, union serialization with System.Text.Json, and control flow obfuscation for .NET and Java teams. Several posts focus on ASP.NET Core, covering middleware, RAG integration, and using passkeys for second factor authentication. The newsletter also features discussions on event-driven architecture versus CRUD over pub/sub and the impact of AI on database schema design. JetBrains announces the Rider 2026.2.3 release and explains how Microsoft helped fix slow startup times for Rider and ReSharper.
TeamCity 2026.2.1 and 2026.1.5 Are Out
JetBrains has released TeamCity 2026.2.1 and 2026.1.5, two bug-fix updates for the On-Premises versions of TeamCity that address more than 40 security vulnerabilities combined. These updates also resolve specific regressions including TFS projects failing to display diffs, YAML configuration import issues from a main repository branch, and MSBuild tools not being detected after the Visual Studio Build Tools 2026 September update. In addition to the numerous security fixes, these releases deliver performance improvements, better compatibility with integrations, and faster, more stable builds for users. A key compatibility feature allows upgrades or downgrades within the same major version without requiring backup restoration because bug-fix releases share a common data format. Users can upgrade via automatic update within TeamCity, direct download from the JetBrains website, or by pulling the updated Docker image from Docker Hub.
Discontinuing Swift Language IDE Support in the Kotlin Multiplatform Plugin
JetBrains is discontinuing Swift language IDE features in the Kotlin Multiplatform plugin starting with IntelliJ IDEA 2026.3 and Android Studio Rabbit 2 | 2026.2.2, including editing, syntax highlighting, and navigation within Swift files and between Swift and Kotlin. Running iOS applications and debugging Kotlin code on iOS will remain fully supported, and Kotlin/Native functionality such as Swift Export is unaffected. The existing Swift functionality will remain available in earlier versions of IntelliJ IDEA, Android Studio, and the KMP plugin, though these older versions will not receive further updates. The decision follows analysis showing limited and declining usage, with most iOS developers on KMP projects preferring Xcode for Swift development. The Swift support, originally developed for AppCode, required substantial effort to stay compatible with changes in Swift, Xcode, and the IntelliJ Platform.
A New Agentic Experience: JetBrains Air in IDEs – EAP Now Open
JetBrains launched the Early Access Program for Air, an agentic experience in its IDEs available as a plugin or in 2026.3 EAP builds. Air orchestrates multiple AI agents in parallel, moving beyond the traditional AI chat model that JetBrains found insufficient for concurrent tasks. It acts as a conduit for existing agents like Codex, GitHub Copilot, Junie, and Claude, requiring no JetBrains AI subscription. The agentic-first UX organizes work into sessions with cost visibility, temporary worktrees, and local or cloud runs, with free Junie Lite for everyday tasks. Air ships with no agents installed, detects agents on the machine, and sends data directly to the user’s provider, while AI Assistant remains available as a separate plugin.
RustRover vs VS Code + rust-analyzer: What Changes in Your Rust Workflow
This post compares RustRover and VS Code with the rust-analyzer extension for Rust development, detailing their architectural differences. VS Code, a general-purpose editor, relies on the rust-analyzer language server to provide completion, diagnostics, inlay hints, navigation, quick-fixes, and refactoring. RustRover is a dedicated professional IDE using JetBrains’ own analysis engine that builds a model of crates, dependencies, targets, and code structure from the Cargo workspace, with built-in debugging, testing, and version control. Key differences include RustRover’s integrated debugger versus VS Code’s need for an extension like CodeLLDB, and RustRover’s project-wide refactoring with affected-usage review. AI assistant capabilities also differ, with RustRover offering agent-driven tasks through Air and JetBrains AI while VS Code supports inline suggestions and agent providers like Copilot. The post offers a five-step migration guide for VS Code users and concludes the choice depends on whether one prefers a modular editor or an integrated IDE experience.
Small Talk with Emiliano Bonilla, CEO and Co-Founder of Synnax
Emiliano Bonilla, CEO of Synnax, built the company after witnessing rocket engine testing operations ruin multi-million-dollar hardware because Excel and Python could not handle real-time control. Synnax is a platform that replaces decades-old aerospace tools, capturing sensor data in real time and tightening the loop between collection and action. The team built its own real-time programming language, Arc, in about six months after finding existing tools unsuitable. Synnax currently focuses on aerospace but is expanding into cryogenic control for quantum computing, oil and gas, and manufacturing. The company uses JetBrains IDEs, citing their debuggers and merge conflict resolution as critical to balancing speed and quality in mission-critical software.
The Companions to Come
JetBrains is extending Kotlin’s companion mechanism with experimental companion blocks and companion extensions in Kotlin 2.5.0. Companion blocks replace the object keyword with a companion block, compiling members as static members on the JVM. Companion extensions allow adding class-level members to any type, even types the developer does not control. These features improve multiplatform interoperability by enabling expected companion block members to be actualized using Java static members. Companion objects remain fully supported and are still required when the companion must implement an interface, but companion blocks are recommended for new code.
The State of Kotlin in 2026 Report
Kotlin turned fifteen in 2026, and the State of Kotlin in 2026 report examines how the language built a mature ecosystem and gained worldwide adoption. The report combines JetBrains research with independent industry data to assess Kotlin’s evolution and answer questions about its staying power and scalability. While Kotlin remains deeply established in Android development, more than half of Kotlin developers now work on backend projects. Among surveyed Kotlin developers, 93% use at least one AI coding tool, and 81% report that AI-generated Kotlin code is fully correct or requires only minor fixes. The report concludes that Kotlin’s evolution is defined by increasing diversity across backend, multiplatform, and AI-assisted development.
Software Quality Assurance Tools and Tips for Developers
Software quality assurance (SQA) has evolved from a final gate to a continuous process integrated throughout the SDLC. The 2025 Stack Overflow Developer Survey shows 84% of developers use AI tools, increasing the need for tighter quality reviews. Shift-left analysis moves checks earlier, catching defects when cheapest and easiest to fix, and poor software quality costs the US at least $2.41 trillion annually. Essential SQA tools include static code analyzers, unit testing frameworks, integration testing tools, performance testers, and security scanners, but no single tool covers every aspect, so a layered toolkit is vital. A balance of automated and manual code review remains important, and best practices include automating repetitive checks, integrating testing into CI/CD, monitoring technical debt, and treating security as integral.
Air Teams: Bring Your Best Agentic Workflows to the Whole Team – and Automate Repeatable Work
JetBrains introduced Air Teams, a shared workspace for agentic development that extends beyond individual developers to teams and organizations. The system comprises four components: Automations for recurring tasks triggered by events or schedules, shared cloud environments with preconfigured tools and credentials, cloud tasks that run in parallel without tying up local machines, and team projects that centralize members, environments, and credits. Automations include templates for code review, bug fixes, and dependency updates, and they run under a project’s service account so they persist after a creator leaves. Shared environments are defined in a repository’s .air/cloud/startup.sh script and can be snapshotted for reuse, with secrets shared without exposing values. Air Teams is available to business customers, with plans to expand to individual customers later.
Rider 2026.2.3 Is Released!
Rider 2026.2.3 is released, adding AI performance analysis to the Monitoring tool window and fixing an issue with the AI Agent Setup widget on Windows. The Monitoring tool window collects runtime data every time an application runs, allowing the AI agent to find bottlenecks and link them to code using the Analyze with AI action, which sends a prompt to the agent to begin the investigation. The agent uses the dottrace-analyze skill to show where time was spent, follow hot paths in code, and provide useful performance insights in the chat. This feature requires Windows, dotUltimate or the All Products Pack, and the AI Assistant plugin. The widget fix addresses issue RIDER-143160, where clicking its taskbar icon with display scaling below 175% failed to open the widget, and updates are available from the IDE, Toolbox App, or website.
A More Reliable Compilation Scheme for Kotlin Multiplatform Modules
Kotlin Multiplatform’s current compilation scheme can cause IDE and compiler disagreements or unexpected resolution of platform-specific declarations from common source sets. In Kotlin 2.5.0-Beta1, an optional separate compilation approach aligns compiler behavior with IDE analysis, making common code resolve only against metadata KLIB declarations. This also eliminates issues like overload selection differing by target and type inference failures in platform code. Separate compilation is experimental and disabled by default, enabled by adding kotlin.kmp.separateCompilation=true to gradle.properties. Known issues include problems with cinterop commonization and single-target modules; library authors must publish metadata KLIBs for the feature to work correctly.
Continuing to Move PHP Open Source Forward
Each year, PhpStorm selects five open-source projects to sponsor for a full year, providing financial support and raising awareness of open source in the PHP community. For this year, the chosen projects are PHPUnit, Lerd, static-php-cli, Composer, and Larabelles, selected from community suggestions based on their impact and need for financing. Sebastian Bergmann, creator and maintainer of PHPUnit, offers the most widely used testing suite for PHP. George Dumitrescu’s Lerd manages local PHP installations and servers, while Jerry Ma’s static-php-cli is used by FrankenPHP and Native PHP. PhpStorm continues its sponsorship of the PHP Foundation and encourages other organizations to contribute to open source, as every bit of support makes a substantial difference when added together.
Designing the Kotlin Multiplatform and TeamCity Integration
The post describes the design of a new TeamCity integration for Kotlin Multiplatform (KMP) developers building iOS apps. The integration addresses common pain points: iOS builds require macOS infrastructure, Apple signing is complex, and there is no guided path from IDE to CI/CD. The solution provides a progressive onboarding flow within the IDE, starting with a tooltip after the first Git push. The flow generates four configuration files (teamcity.yaml, Fastfile, Appfile, Gemfile) and runs a build and tests on a hosted macOS agent, then guides the developer through a single form for Apple signing and TestFlight publishing, and finally automates the pipeline on GitHub pushes. TeamCity Cloud provides hosted macOS agents and a free starting tier, so no Mac is required. The design was validated through usability sessions and focuses on meeting the developer at the right moment with minimal configuration.
Small Talk With Prasun Kumar, CEO and Founder of Oppex AI
Oppex AI builds AI agents that help developers resolve production incidents by gathering context before the engineer is paged. The agents collect logs, cloud metrics, database health, affected customers, recent code changes, and past incident history, then present a recommendation. Because developer logs are not plain English, the team constructs a knowledge graph of how the entire system connects. They harden the agent by pitting it against a chaos monkey that breaks test systems without revealing the method, forcing the agent to learn. The 15-person team has launched the product with early enterprise customers and aims to bring mean time to resolve under 10 minutes, eventually moving toward autonomous system healing.
Topics they write about
All topics →Weekly digest
The best engineering reads, once a week.