August 2026 Summaries

JetBrains will retire its Teacher Pack for Bootcamps, citing expanded education offerings that now address the needs of educators, students, institutions, and course creators through more specialized programs. Bootcamps may submit a final application by September 30, 2026, with approved applicants receiving one final set of student coupons valid for up to six months; new applications, additional coupons, and new instructor IDE access will end on October 1, 2026. Existing instructor licenses and issued student coupons will remain usable until their expiration dates, while the program will be fully retired on April 1, 2027, when remaining coupons and the associated graduation discount end. JetBrains directs accredited-school educators to its individual or classroom Teacher Packs, course publishers to the Course Creators Program, eligible students to the Student Pack, and other users to free core functionality in IntelliJ IDEA and PyCharm or non-commercial licenses for certain other IDEs.

JetBrains researchers propose an evaluation framework for agentic coding systems that supplements resolve rate, or the percentage of benchmark tasks solved, with measures of execution efficiency, patch quality, and process quality drawn from agent trajectories. Using Junie to compare models across coding benchmarks, they found that similar or identical task outcomes can mask substantial differences in cost, number of steps, repository exploration, validation behavior, patch scope, redundancy, and hallucinated dependencies or APIs. Claude Opus 4.7 showed stronger diagnosis and more contained patches but sometimes failed to complete or validate fixes, while Gemini 3.5 Flash more frequently ran executable checks but often took longer paths, repeated work, and produced broader or less grounded changes. A wider comparison found GPT-5.5 had the highest resolve rate and consistently validated changes, Opus led patch-quality measures, and Qwen 3.6 27B FP8 offered much lower cost at lower task success. The authors emphasize that these profiles depend on the specific agent setup and that LLM-judge assessments are imperfect, arguing that detailed evidence about how agents work can improve model selection, prompting, and agent design beyond leaderboard rankings alone.

Fine-tuning is essential for deploying pretrained object detectors on specialized data because models trained primarily on COCO’s common everyday categories perform near zero-shot accuracy on unfamiliar classes and visual domains such as industrial cable damage, bone fractures in X-rays, and densely packed soda bottles. The study compared YOLOv12, YOLO26, and RF-DETR models in small and medium or base variants, first reproducing broadly comparable COCO accuracy baselines while noting that real deployment latency varies with hardware and framework optimization. Using PyCharm with separate virtual environments for incompatible model dependencies and remote GPU training, the models were fine-tuned for 10 epochs on three RF100 datasets. Fine-tuning substantially improved results, with soda-bottle detection achieving high performance across all models, cable-damage detection proving reliable but difficult to localize precisely, and bone-fracture detection remaining challenging because of the large shift from natural photographs to X-ray imagery. RF-DETR Base was the most consistently strong model, particularly on unfamiliar domains, but the findings emphasize that no single detector is universally best and that model selection should account for target-domain similarity, accuracy, latency, model size, licensing, and the need for additional data or domain-specific pretraining.

JetBrains reported that its Cadence cloud-compute service for PyCharm was compromised through CVE-2026-63077, a critical TeamCity vulnerability that enabled unauthenticated remote command execution on the affected server, api.cadence.jetbrains.com. The intrusion occurred between August 8 and August 24, 2026, was discovered on August 23, and led JetBrains to take the server offline while it investigates. Attackers accessed and extracted user data including names, usernames, email addresses, login timestamps, and IP addresses; compromised a 2024 server backup; accessed JetBrains AWS resources and S3 files; and may have obtained synchronized PyCharm project code and credentials used in Cadence executions. JetBrains has invalidated Cadence plugin access tokens, contacted affected users, and acknowledged that the server should have been patched. Users are urged to immediately revoke and rotate all potentially exposed credentials, inspect repositories, cloud accounts, storage, and connected services for suspicious activity, and consider Cadence execution data, uploaded files, secrets, and outputs untrusted.

The fifth annual Django Developers Survey, based on nearly 3,500 respondents in over 40 countries, portrays Django in 2026 as a stable and widely trusted framework while its surrounding development tools evolve rapidly. PostgreSQL, Django templates, regular framework upgrades, monolithic deployments, and self-hosting remain common, while developers increasingly use AI for coding, debugging, research, and learning, though most retain direct supervision over AI-generated changes rather than delegating complex tasks autonomously. New Python tools such as uv and Ruff are consolidating environment management, linting, and formatting workflows, while type hints are becoming standard despite no clear consensus on type-checking tools. Testing and CI/CD adoption, led by pytest and GitHub Actions, are presented as essential safeguards as AI agents take on more coding work. Django continues to support both server-rendered applications and API-driven or JavaScript frontend architectures, with htmx growing substantially alongside steady React use. Overall, the report argues that Django’s mature, dependable core enables developers to experiment with AI, typing, modern tooling, and frontend approaches without needing to replace the underlying framework.

Project Loom modernizes Java concurrency through virtual threads, scoped values, and structured concurrency, aiming to make highly concurrent applications more scalable, understandable, and reliable than approaches based on platform-thread pools, CompletableFuture, and ThreadLocal variables. Virtual threads, stable since Java 21, are lightweight JVM-managed threads suited to blocking I/O workloads, while scoped values, stable since Java 25, provide immutable and automatically cleaned-up contextual data sharing. Structured concurrency, a preview feature in Java 27, organizes related subtasks into bounded scopes with coordinated joining, automatic cancellation, explicit failure policies, and improved observability. Using a customer-profile example that retrieves orders and recommendations concurrently, the post contrasts manual timeout handling, cancellation, exception unwrapping, and fragile context propagation with a Loom-based implementation that expresses these policies directly through StructuredTaskScope and ScopedValue. It also describes IntelliJ IDEA support for creating, debugging, and inspecting virtual and structured threads, including thread dumps that show task hierarchies, and outlines how to configure Java 27 early-access and preview features for experimentation.

JetBrains’ preliminary CLion roadmap through late 2026 prioritizes agentic AI workflows, embedded development, debugger enhancements, and general IDE maintenance, with planned features subject to changing priorities. Upcoming releases are expected to add an AI skill for diagnosing ARM Cortex-M HardFault crashes using memory, register, and disassembly data, plus agent-assisted help for resolving project setup failures. Embedded-focused debugger improvements include expanded DAP capabilities, JSON-based debug profile import and configuration, a dedicated Lauterbach TRACE32 profile, consolidation of embedded run settings into debug profiles, and support for QNX projects, including the QCC compiler and x86-64 and AArch64 targets. CLion 2026.3 is also planned to support LLDB 21 on Windows, update bundled GDB to 17.2 and CMake to 4.4.2, improve configuration warnings, provide default code-resolution settings for files outside project build configurations, and add ISPC language support. Additional work will address responsiveness, Dev Container integration, the transition from the legacy Classic engine to Nova, and the removal of bundled JavaScript and TypeScript support while keeping it available as an optional plugin.

JetBrains Research has open-sourced DPTrainer, a library that integrates Opacus differential privacy capabilities with Hugging Face’s Trainer ecosystem, allowing developers to use privacy-preserving DP-SGD without rewriting training loops or modifying trainer code. Differential privacy limits the influence of any individual training example through per-sample gradient clipping and calibrated noise, helping protect sensitive data from memorization and membership inference attacks while introducing a trade-off between privacy and model performance governed by a cumulative privacy budget. DPTrainer extends the standard Trainer with configurable privacy arguments and can dynamically patch specialized Trainer subclasses such as TRL’s DPOTrainer and SFTTrainer, preserving their task-specific behavior while adding DP-SGD. It automates per-sample gradient computation, optimizer wrapping, Poisson-sampled data loading, noise calibration, privacy accounting, checkpoint state restoration, and budget-aware early stopping, aiming to make auditable differential privacy training more practical for teams developing transformers on sensitive data.

JetBrains has expanded its OpenTelemetry plugin beyond Rider to IntelliJ IDEA, GoLand, PyCharm, and WebStorm in the 2026.2 release, allowing developers to inspect local application logs, metrics, traces, and service maps directly within supported IDEs without deploying a separate observability backend. Designed for development and testing rather than replacing debuggers, profilers, or production monitoring platforms, the plugin helps users investigate errors, trace request paths across services and dependencies, identify latency issues, and validate emitted telemetry before release. It works with already instrumented Java, Python, Go, and .NET applications by directing their OTLP exports to a built-in receiver, and it can also integrate with existing local OpenTelemetry Collector pipelines. The plugin includes searchable logs, metric charts, span-level trace inspection, and service maps generated from observed traffic, while experimental MCP support enables compatible coding agents to query telemetry data and service relationships through the JetBrains MCP server.

Canonical is adopting Rust selectively in Ubuntu’s core system software as a long-term effort to improve memory safety, security, reliability, and maintainability across its large deployment base, rather than pursuing a wholesale rewrite. Ubuntu 26.04 LTS introduces uutils coreutils as a compatibility-focused Rust replacement for GNU coreutils and sudo-rs, which intentionally modernizes some sudo behavior, while future plans include ntpd-rs for unified NTP, NTS, and PTP time synchronization and UPKI for certificate revocation support in Linux utilities. The initiative accepts measured compatibility trade-offs, using LTS release boundaries and continued availability of legacy tools to give users fallback options. Canonical is also adapting its distribution practices for Rust by vendoring dependencies, embedding software bills of materials in Rust binaries through cargo auditable, and using snaps to deliver modern applications across older Ubuntu releases. Looking ahead, the company is evaluating Rust implementations of compression libraries and intends to support upstream projects, audits, maintainers, and broader supply-chain security efforts.

JetBrains Research’s 2026 Developer Ecosystem Survey of more than 15,000 professional developers found that respondents estimated roughly 47% of their work code was fully generated by AI agents, 38% was written with AI assistance, and 27% was written manually, with totals affected by bucketed self-reporting. More than half of developers said they manually wrote under 20% of their code, although only about 22% relied on agents for over 80% of it. Senior developers were more likely than juniors to use highly agentic workflows, while Codex users reported the highest concentration of heavy agent use, ahead of Claude Code and Cursor users. Go, JavaScript, and TypeScript developers reported the largest average shares of agent-generated code, whereas C and C++ developers retained the greatest amount of manual coding, and developers in China, Japan, and South Korea showed substantially higher adoption of highly agentic workflows than those in Europe and the UK. The study grouped respondents into agentic coders, who comprised about 31% of developers and generated an average of 84% of their code through agents; AI-assisted coders, the largest group at 47%; and manual coders, 23% of respondents who still wrote most code themselves.

DataGrip’s latest release adds AI agent integration for tools such as Claude Code, Codex, and Junie, extending them with database capabilities through built-in MCP tools and skills. A new video demonstrates how users can create data sources from descriptions, JDBC URLs, or imported connections; ask natural-language questions about database schemas; generate SQL queries from text requests; and identify and safely remove inappropriate tables through dependency checks. It also explains object and file targeting through the @dbObject and @fileName identifiers, while inviting users to suggest additional AI-agent scenarios for future support.

Compose Multiplatform 1.12.0 introduces experimental AI-agent support in Compose Hot Reload through a Model Context Protocol server, allowing coding agents to reload applications, inspect semantic trees, capture screenshots, simulate user input, and review logs to validate their changes. The release also improves web rendering with automatic font fallback, downloading relevant Noto font subsets when needed so unsupported scripts and emoji can display without manually bundled fonts. For desktop development, an experimental v2 window and dialog API provides more control over screen selection, positioning, sizing constraints, intrinsic content sizing, and dialog placement relative to parent windows, while distinguishing requested window state from the state currently applied by the operating system.

JetBrains Research Podcast examines deeper questions about software development and AI through conversations with researchers and practitioners rather than focusing solely on productivity claims or benchmark scores. Episodes discuss how collaborative team culture influences developer well-being and code quality, how five historical cultures of programming produce different views of reliability and failure, and why software development cannot be reduced to implementing specifications. Guests also consider how computer science education should emphasize learning, mathematical understanding, and the ability to assess AI-generated solutions amid rapid technological change. The podcast highlights SWE-rebench, a benchmark designed to evaluate coding agents on tasks unavailable during training, arguing that verifiable outcomes such as passing tests make software engineering especially useful for AI training and evaluation. It also explores computer vision’s continuing practical value, including OpenCV’s broad yet lightly resourced infrastructure and FitWise AI’s efforts to help sports organizations use camera data to analyze athlete performance and injury risk.

JetBrains has introduced Junie Local, a free on-device version of its AI coding agent that runs a tuned 4-bit Qwen3.6-27B model entirely on a user’s Mac, keeping prompts, source code, and changes local without credits, subscriptions, or cloud connectivity after installation. Activated through the `/local` command, it preserves Junie’s existing agent features while eliminating manual local-runtime setup, though it requires approximately 20 GB of downloads and an M5 Mac with 64 GB of RAM. JetBrains says it optimized the system primarily for file-reading prefill performance, using M5 hardware features, KV-cache reuse, and speculative decoding, and selected Qwen3.6 instead of a newer model because disabling reasoning produced faster performance with limited quality loss. Internal evaluations reportedly placed the local model near Sonnet 4.5 on JetBrains’ private tests, although the company notes that cloud models may perform better on complex architectural reasoning. Junie Local is positioned for repetitive or extensive tasks such as refactoring, test coverage improvements, upgrades, migrations, and repository exploration, while offering particular benefits for privacy-sensitive or offline work. JetBrains acknowledges the demanding hardware requirements and plans to expand support to lower-memory systems and additional platforms, including Nvidia hardware.

JetBrains optimized its Junie Local coding agent to run Qwen3.6-27B efficiently on Apple M5 MacBooks by improving the agent workflow, model configuration, and inference engine rather than focusing only on token generation speed. Key changes include retaining a rolling context and reusable KV cache across tasks, caching the session prefix, adapting progress reporting to Qwen’s plain-text behavior, and disabling optional LLM calls and multi-agent processing. The team used 4-bit quantization and disabled reasoning because it delivered roughly twice the task speed with little quality loss, while an MLX-VLM patch using M5-specific 8-bit arithmetic improved context-prefill performance by about 40%. Combined multi-token prediction and n-gram speculative decoding further doubled generation speed in some cases. Qwen3.8-27B was not selected because it depends on reasoning mode for reliable performance, generating substantially more tokens and producing an estimated fourfold slowdown on Mac hardware.

Modern Go Guidelines is an open-source GoLand project designed to help AI coding agents generate current, version-compatible Go code by supplying targeted guidance for language and standard-library features from Go 1.0 through Go 1.27. The tool reads the Go version specified in a project’s go.mod file and exposes only applicable recommendations, preventing agents from suggesting unsupported features while reducing unnecessary context. Its CLI uses a progressive-disclosure model: the list command provides concise relevant rules, while explain supplies detailed descriptions and before-and-after examples for selected guidelines. Covered practices include modern alternatives such as slices.Contains, min and max, sync.WaitGroup.Go, errors.AsType, and newer string and byte utilities, complementing automated migration tools like go fix by helping agents write modern patterns initially. Available through a marketplace plugin or local repository integration, it requires a local Go toolchain, installs its command-line component into a cache, and does not modify the user’s project.

Spring Boot supports externalized configuration through property files, environment variables, system properties, and command-line arguments, allowing a single application artifact to operate across environments. Recommended practices separate safe application defaults, deployment-specific settings, and sensitive secrets, with secrets managed through dedicated services rather than source control. For related settings, type-safe immutable `@ConfigurationProperties` records are preferred over scattered `@Value` expressions because they support validation, metadata, IDE navigation, and refactoring, while startup validation should make applications fail early when required values are missing or invalid. Developers should understand Spring Boot’s property-source precedence, use environment variables for platform-provided overrides, and avoid hard-coding credentials or environment-specific endpoints. Configuration approaches should reflect the deployment model, such as environment overrides for monoliths, ConfigMaps and secret systems for containers, and centralized configuration servers for microservices, while IntelliJ IDEA can help diagnose effective values, property sources, and overrides during development.

GoLand 2026.2 adds day-one support for Go 1.27, including editor recognition of new language features such as generic methods, promoted struct field names in composite literals, and improved function type inference. The IDE incorporates Go 1.27’s expanded official go fix modernizers as in-editor inspections and quick-fixes, with project-wide review, bulk application, and an optional pre-commit check. It also supports Go’s new goroutine leak profile, enabling developers to capture or import pprof data and investigate permanently blocked goroutines through flame graphs, call trees, visualizations, and source annotations. Updated Modern Go Code Guidelines provide AI coding agents with version-aware context on Go 1.27 features, standard library APIs, and current practices. The GoLand team is also hosting a free online Go 1.27 Release Party on August 25, 2026, featuring presentations, demos, live coding, IDE coverage, and a Q&A session.

PyCharm is presented as an IDE for Django developers using AI agents, emphasizing that developers remain responsible for understanding, reviewing, and shipping generated code despite widespread AI adoption. It supports native integrations with agents including Codex, Claude Agent, Junie, and Gemini, along with additional ACP-compatible tools, personal API credentials, and local models through Ollama or LM Studio. PyCharm 2026.2 adds reusable AI skills for providing project-specific conventions and offers curated skills for technologies such as React, Postgres, and Playwright. Its Django support includes awareness of Django 6.0 template partials and adapts to the framework version used by each project. The IDE also provides visual diffs, Git tools, Local History, Django Logical Structure, endpoint inspection and testing, and database browsing, enabling developers to review AI-generated changes, understand application architecture, and verify API and data updates without leaving the development environment.

The article argues that Kotlin backend functions should expose expected business failures in their return types rather than hiding them through exceptions or `Unit` returns, using `Either<DomainError, Success>` and sealed error interfaces to make outcomes explicit and compiler-enforced. It distinguishes API client errors, which can be handled as broad HTTP 4xx responses; unexpected infrastructure failures, which should remain exceptions and yield operational signals such as 500 responses and alerts; and domain errors, such as invalid signing codes or closed signing windows, which healthy clients must handle differently and therefore belong in the contract. Narrow sealed error unions per public method enable exhaustive `when` handling and avoid anti-patterns such as `Either<Throwable, Unit>` or overly broad shared error types that force callers to consider impossible cases. The approach can be composed with Kotlin early returns or Arrow utilities, while HTTP mapping should occur only at route boundaries so lower layers remain focused on business outcomes. Although explicit error types add verbosity, the article maintains that they improve code review, client-server consistency, AI-generated code verification, testing, and maintainability by making a function’s real behavior visible in its signature.

PyCharm 2026.2 delivers 263 fixes and improvements focused on making Python code analysis more accurate, reducing false positives, and improving everyday development workflows. The release strengthens SQLAlchemy 2.0 support, including relationship forward references, Session.get() return inference, hybrid properties, and mixin-defined model attributes, while broader type-system fixes improve control-flow narrowing, annotation handling, iterable unpacking, augmented assignment, Self behavior, constructor return types, enum literals, and decorator-derived parameter inference. Auto-import and completion now better reuse existing imports, support nested classes, assist with unittest.mock.patch() string targets, and generate fully typed overrides for built-in methods. Additional editor enhancements add clickable generic type inlay hints and f-string format-spec validation, while refactoring now updates module references after module renames. The update also introduces more granular type-checker suppression codes and incorporates user-reported examples to make PyCharm’s Python understanding more precise and predictable.

JetBrains has released Rider 2026.2.1 and ReSharper 2026.2.1, the first minor update in the 2026.2 cycle, with an emphasis on AI-assisted development, performance, and tooling improvements. Rider adds bundled AI agent skills for code refactoring, debugging across .NET, Unity, Unreal Engine, and mixed-language projects, and analyzing dotTrace snapshots from Unity profiling; JetBrains reports that access to Rider’s refactoring engine reduced median task time by 83%, cost by 64%, and tool calls by 63% across tested C# refactoring tasks. Rider quality-check hooks now support Codex alongside Claude Code, while Unreal Engine code-authoring and test-authoring skills have been updated and may require manual reinstallation. ReSharper now uses Out-of-Process mode by default, enabled by dotCover’s OOP support, and its type and project dependency diagrams are also available in that mode. The update additionally introduces a newer Junie version with support for Claude Opus 5.

JetBrains Rider 2026.2.1 introduces a bundled refactoring-code skill that lets AI agents invoke Rider’s ReSharper-powered C# refactoring engine rather than attempting structural changes through text edits and repeated compiler checks. In an evaluation of 15 tasks covering eight refactoring types, including renaming symbols, extracting methods or interfaces, changing API signatures, moving types, reorganizing namespaces, and safe deletion, access to the skill reduced median task time from 157.9 to 26.6 seconds, cost per solved task from $0.52 to $0.19, and tool calls per task from 17.0 to 6.2. The comparison used the same model, prompts, and approximately ten runs per task, differing only in whether the Rider skill was available. Without it, the model frequently relied on text-processing commands, Git, and 163 build calls to discover errors caused by edits; with it, build calls dropped to three because Rider can resolve symbols, references, overloads, and dependencies directly through its syntax model. The skill improved eight tasks substantially, particularly complex extraction and relocation operations, though some already-fast tasks saw limited benefit and several were not solved by one or both approaches. Rider activates the capability automatically for C# refactoring requests, with specific instructions such as extracting an interface or renaming a symbol expected to make use of the available IDE operation.

YouTrack presents itself as a migration option for organizations moving away from Atlassian Jira, Confluence, and Jira Service Management amid Atlassian’s Data Center product changes and evolving AI data practices. Available as self-hosted Server or AWS-hosted Cloud, YouTrack combines project management, knowledge-base, and helpdesk capabilities, while allowing administrators to enable, configure, or avoid AI features. Its import tools can transfer projects, users, issues, comments, attachments, histories, custom fields, links, time logs, Confluence spaces and pages, and Jira Service Management tickets, with continuous import supporting parallel use during a trial. Organizations must typically recreate items not automatically mapped, including dashboards, boards, reports, SLA policies, automations, workflows, notification settings, and Marketplace app functionality, although these can be adapted through built-in features, custom JavaScript workflows, apps, or consulting partners. The guide recommends testing a small mix of simple and complex projects before a full migration, highlights free and trial plans, and cites customer examples of phased moves to YouTrack Server and consolidated development and support operations.

Air’s latest release introduces a multiproject view that lets users manage tasks and run agents across several repositories within one window, with sidebar organization by project or status, cross-project search, and visible project and branch context for each task. The update also adds an inline Markdown editing experience that renders headings, lists, code blocks, and syntax formatting as readable documents while preserving standard Markdown editing behavior. For Windows users, the release fixes support for Chinese, Japanese, Korean, and other input method editors, addressing a widely reported issue. Additional changes include a first-launch customization screen for selecting keymaps, themes, and accent colors, along with Agent Review controls that allow users to choose the reviewing agent and model.

JetBrains’ 2026 Developer Ecosystem Survey of more than 15,000 professional developers reports that AI coding agents have become common workplace tools, with 90% used at least weekly and 68% used daily between May and July 2026. Claude Code led adoption at 39% globally and 47% in the United States, substantially surpassing GitHub Copilot and becoming the primary AI coding tool for 31% of developers, while Codex grew from 3% adoption in January to 16% and sharply increased in awareness. GitHub Copilot’s adoption declined to 21% despite retaining high global awareness, while Cursor’s usage fell to 12%, particularly in China; OpenCode reached 7% adoption with 42% awareness, and Google Antigravity held steady at 6% while gaining popularity in India. Around 9% of respondents used JetBrains AI tools, and JetBrains highlighted integrations with several agents, its preview Air agentic development environment, and JetBrains Central for managing agent-driven workflows. The survey uses multilingual responses, regional quotas, and statistical weighting to represent the global professional developer population.

JetBrains has expanded Qodana’s security analysis by integrating OpenGrep-powered inspections for .NET and JavaScript projects, adding hundreds of checks for vulnerabilities such as injection attacks, XSS, path traversal, SSRF, unsafe data flows, and insecure coding patterns. The integration allows teams to use community, third-party, or custom OpenGrep rules while viewing results alongside Qodana’s existing static analysis, dependency scanning, license auditing, quality gates, vulnerability detection, and taint analysis in IDEs, pull requests, reports, and CI/CD pipelines. JetBrains emphasizes that the deterministic static-analysis approach is intended to provide predictable, early detection without requiring another standalone security tool, and it plans transparent evaluation through its SABER benchmarking initiative, which measures detection and false-positive performance. OpenGrep supplements rather than replaces Qodana’s existing capabilities, is included for supported languages depending on Qodana edition, and is expected to gain Kotlin and Java support alongside broader OWASP and CWE coverage in future releases.

JetBrains Toolbox App 3.7 introduces JVM memory optimizations enabled by default, improving memory management, code-cache behavior, and garbage collection across operating systems without manual configuration. Windows users running version 3.4 or earlier are advised to update to retain JetBrains Account sign-in functionality, as older versions may not reliably store or refresh credentials. The release also improves IDE installation and updates on macOS 27, adds compatibility with Windows Smart App Control, strengthens macOS patch-update verification by cleaning unsealed runtime files or downloading a fresh copy when necessary, and addresses a potential session-expiration cause related to temporary network interruptions.

JetBrains has made Google’s Gemini 3.7 Flash the default model for its Junie AI coding agent in both the IDE plugin and Junie CLI, offering a limited-time 40% discount on base pricing. The company describes the model as an upgrade over Gemini 3.6 Flash, citing Google benchmark results showing stronger performance on long-horizon software-engineering tasks and production-ready code generation. JetBrains also reports that, on its private benchmark based on recent internal code commits, Gemini 3.7 Flash matched the task-solving rate of its Sonnet-5 midtier model while costing roughly one-third as much per task. The change is intended to provide a lower-cost default model for everyday coding work without requiring users to configure anything.

JetBrains describes onboarding as a months-long process that begins after a candidate accepts an offer and combines practical preparation, workplace setup, team integration, and ongoing feedback. Before starting, new hires receive contract, HR, profile setup, and first-day information, while their first day includes introductions, equipment, access to internal tools, and guidance on payroll, benefits, and time off. In the following weeks, employees learn team workflows and are supported by a Team Partner and a Buddy who can help with informal questions and everyday navigation. During the first months, role-specific content, tasks, new-hire connections, and JetDive sessions introduce employees to the company, products, and colleagues at a manageable pace. The probation period centers on mutually agreed expectations, regular manager check-ins, skill development, and open discussion of workload and support needs, with the aim of ensuring clarity about role fit and helping employees become productive and comfortable within the organization.

klibs.io, launched in December 2024 to simplify Kotlin Multiplatform library discovery, has expanded to a catalog of more than 4,200 projects aggregated from GitHub and Maven Central. The platform uses LLM-assisted metadata refinement when source information is incomplete and offers multi-term search, platform and target filters, curated categories, and sorting by relevance, GitHub stars, or dependent counts. Its project pages consolidate descriptions, documentation, supported platforms, versions, dependency usage, licenses, and activity data to help developers compare libraries. New AI integrations, including an MCP server and a Kotlin Multiplatform Libraries expert skill, allow coding agents to access current library data, verify platform support, and identify dependency coordinates and stable versions. As an open-source project, klibs.io also invites users and library authors to improve metadata, report issues, contribute code, and provide feedback through Kotlin Slack.

Compose HTML is being explored as a potential server-side rendering solution for the JVM, enabling Kotlin developers to create type-safe, reusable HTML components in Compose rather than using string-based templates such as Thymeleaf or JSP. The proposal would add a JVM target and functions that compose an HTML tree once and serialize it to a response string or bytes, supporting conventional server-rendered applications with standard HTTP forms and redirects but initially without browser-side effects, recomposition, or active event listeners. Existing Compose web projects including Kobweb, Kilua, and Summon demonstrate community interest through approaches such as prerendering, SSR, and hydration, while a shared Compose HTML SSR foundation could support future Spring Boot and Ktor integrations. Illustrative API concepts show composable functions serving directly as pages or route handlers, though the author emphasizes that these are speculative examples rather than a roadmap. Longer-term questions include hydration, client-server state synchronization, and shared UI code, while the intended scope is a small core rendering layer whose framework integrations and libraries would be developed by the wider Kotlin ecosystem.

Qodana’s proposed expansion into DevOps and platform engineering aims to provide the same integrated code-quality experience for infrastructure artifacts that it currently offers for application code. The piece argues that Kubernetes manifests, Terraform, Dockerfiles, CI workflows, Ansible playbooks, and container configurations are often checked through disconnected tools with inconsistent configurations, severity systems, and CI integrations, leaving security, reliability, and operational issues insufficiently reviewed. A Qodana DevOps Linter could unify findings across major infrastructure domains under a shared interface, severity model, quality gate, IDE feedback loop, and qodana.yaml configuration, while enabling cross-domain analysis such as evaluating relationships between Terraform resources and Helm charts. Still in early exploration, the concept seeks practitioner feedback on whether unified infrastructure quality standards and support for additional tools such as Pulumi, CDK, or GitLab CI would address a meaningful need.

JetBrains and DeepLearning.AI have launched a free course, AI Coding Workflows: Hybrid to Local, using PyCharm and AI Chat to explore how developers can gain greater control, model choice, privacy, and cost efficiency through hybrid and local AI workflows. The course begins with Claude Code, demonstrating how specifications, specialist subagents, context isolation, smaller implementation models, and performance metrics can make coding tasks more manageable and less expensive. It then moves to OpenCode, OpenRouter, and DeepSeek models to show how changing agents, inference providers, and models expands workflow flexibility, including configurable implementer subagents. Later lessons examine hybrid setups using LM Studio and Gemma 4 12B on a 32 GB laptop, followed by a fully local workflow with Qwen 3.5 27B, with results suggesting that structured guardrails can help smaller or local models perform effectively. Throughout, the course emphasizes measuring tokens, cost, time, and outcomes to evaluate tradeoffs, while positioning hybrid and local AI as increasingly relevant for sovereign AI, security, privacy, and human-in-the-loop development.

IntelliJ IDEA integrates AI across the development workflow rather than limiting it to chat, offering predictive AI completion for related edits and method generation, in-editor prompts for generating or transforming code with reviewable diffs, and contextual AI Actions for explaining code, creating tests, and writing documentation. For larger tasks, its Agent Client Protocol supports JetBrains’ Junie and third-party coding agents that can modify files, run tests, and present changes for IDE-based review, while reusable skills provide agents with repeatable task-specific instructions. Bring Your Own Key support allows organizations to connect approved third-party model providers to AI chat and selected features. Additional tools can explain stack traces directly in the console and generate commit messages from staged changes, emphasizing AI assistance embedded in existing coding, debugging, and review activities.

IntelliJ IDEA’s AI Assistant supports Agent Skills, reusable capabilities that provide AI agents with specialized knowledge and behavior for agentic development workflows. Its Skills Manager allows developers to discover and install skills detected on their systems or obtained from repositories, with installation options available globally, by project, or for individual agents. JetBrains supplies a default GitHub-hosted repository of skills reviewed for security vulnerabilities, while organizations can add internal repositories containing team-verified skills. Agents can automatically select relevant skills from a prompt, such as using a Spring Boot skill to generate REST API tests, or developers can invoke skills directly through agent-specific commands.

PyCharm’s Agent Environment Coordinator skill is designed to help AI coding agents use the correct Python interpreter and project environment instead of defaulting to and potentially polluting system Python installations. In tests involving 28 environment-related Python tasks across six AI models, average task success reportedly rose from 68% without the skill to 98% with it, with individual models improving to between 95% and 100% success. The skill allows agents to query PyCharm for the appropriate interpreter and environment-management tool, such as uv, Poetry, virtualenv, or conda, or to configure an interpreter when none exists, while leaving command construction to the agent. The evaluation penalized system-environment pollution and was run three times per model using Harbor, suggesting that improved scores reflected both more successful task completion and cleaner environment handling. Available through a JetBrains AI subscription in PyCharm 2026.2.1, the feature is part of the IDE’s bundled, manageable AI skills.

PyCharm plans to unbundle and deprecate several low-usage plugins beginning with version 2026.2, including Data Wrangler, Hugging Face, Google Colab, Spark and PySpark support, AI Playground, AI Agents Debugger, dbt, and Databricks. JetBrains says the change is intended to reduce maintenance demands, keep the IDE responsive, and focus development on features with broader adoption among Python developers. Affected plugins will remain available through the JetBrains Marketplace for PyCharm 2026.2, and their source code will be moved to an Obsolete Plugins repository so users and community maintainers can build and install them manually. Beginning with PyCharm 2026.3, the PyCharm team will no longer publish compatible plugin versions, although additional low-usage plugins may be handled similarly in future releases.

PyCharm’s new Jupyter skill lets AI agents work directly with a live Jupyter kernel rather than editing notebook JSON files and launching disposable shell subprocesses, preserving variables, models, imports, and data across notebook cells while reducing corruption risks. Through an MCP-based tool interface, agents can create, edit, and run notebooks, monitor kernels, wait for lengthy executions without repeated polling, and retrieve only newly streamed output, reducing idle context usage. In tests on 12 MLGym machine-learning tasks, Claude Opus 5 completed all tasks in kernel, shell, and mixed modes, but the kernel-only approach cost $59.09 versus $67.06 for shell-only operation, largely because 98% of inputs were lower-cost cache reads compared with 82% for the shell. Cost advantages varied by model and workload, with the kernel especially beneficial for long stateful Opus tasks but not always cheaper for short tasks or Codex models. The feature, available through JetBrains AI subscriptions in PyCharm 2026.2.1, improves notebook workflows but still requires agents to be instructed to save artifacts and does not overcome difficult machine-learning problems that need stronger methods or human involvement.

JetBrains’ 2025 State of Developer Ecosystem survey, based on 8,837 responses, examines actual changes in developers’ main programming languages over the previous year rather than relying on stated migration plans. Project requirements remain the leading reason for language switches, although motivations vary: Kotlin attracts developers primarily through its modern features and improved development experience, Go through performance and scalability, Python through its ecosystem, and C# and C++ largely through project needs. C showed unexpectedly low retention, with roughly half of its former main-language users moving elsewhere, often citing a desire to learn newer languages or gain modern features. Python is the most common destination for switchers from most languages, while Java developers most often move toward Python and TypeScript, Kotlin gains mainly from Java, and TypeScript and PHP draw heavily from JavaScript. The findings also identify a skills progression from HTML/CSS to JavaScript and then TypeScript, with JavaScript both gaining and losing developers for job-market reasons, and suggest that TypeScript, Rust, Python, and Go retain substantial growth potential.

Agent Client Protocol (ACP) provides a standardized connection between IntelliJ IDEA and AI coding agents, allowing developers to use bundled agents such as Codex, Claude Agent, and Junie or add other compatible options without separate plugins or bespoke integrations. Similar to how the Language Server Protocol simplified language tooling, ACP uses JSON-RPC to let the IDE communicate with local agent processes while preserving each agent’s distinct models, authentication, planning behavior, tools, commands, and optional capabilities. IntelliJ IDEA remains the workspace for navigating projects, reviewing diffs, and managing edits, while agents handle tasks through the shared interface and can receive extra context via MCP servers. Developers can install public agents from the ACP Registry, which manages installation, updates, and uninstalling, or connect internal agents through an acp.json configuration file that specifies executable commands, arguments, and optional environment variables. The approach enables teams to select specialized agents for different work, retain control over credentials and privacy considerations, and switch agents if a provider becomes unavailable without leaving the same IntelliJ IDEA project.

PyCharm 2026.2.1 expands AI-assisted development with agent skills that let tools such as Claude Code and Codex create, edit, and execute Jupyter notebooks through PyCharm’s live kernel, preserving notebook state across cells, while an environment coordinator directs agents to use the project’s configured Python interpreter and package manager. The release also adds a third-party marimo plugin for working with reactive, Git-friendly Python notebooks, and it unbundles and deprecates lower-use plugins including Data Wrangler, Hugging Face, and Google Colab support, though compatible Marketplace versions remain available. Package management has been redesigned with a dependency tree, faster search, environment visibility, support for uv and Poetry dependency groups, VCS installations, repository controls, and improved Remote Development behavior. Type checking now provides more detailed mismatch explanations, consistent comparisons for composite types, and linked type information, while fixes prevent automatic virtual-environment creation for end-of-life Python versions and improve inference for SQLAlchemy and SQLModel Session.get() calls.

WebStorm has introduced support for the open Agent Client Protocol (ACP), which separates AI agents from the IDE much as the Language Server Protocol separated language tooling from editors, allowing developers to use compatible agents from providers such as Anthropic, OpenAI, Google, GitHub Copilot, and Claude Code without requiring a JetBrains AI subscription. ACP standardizes the exchange of project context and agent actions, supports curated registry agents and privately configured agents, and enables bring-your-own-key deployments across cloud or local model infrastructure. The approach is intended to let developers switch among specialized agents for tasks such as UI implementation, refactoring, debugging, code review, documentation, and commit-message generation while retaining WebStorm’s indexing, navigation, and refactoring capabilities. A highlighted workflow combines a frontend-focused agent with Figma Connect and Chrome DevTools Connect to translate designs into React components, inspect browser errors, apply fixes, and verify results from within the IDE. For organizations, ACP is positioned as a way to control approved providers, maintain data-compliance boundaries, standardize available tools, and deploy custom agents containing internal knowledge and coding standards.

Alexey Gopachenko’s 20-year career at JetBrains has centered on helping developers improve software quality, beginning with TeamCity features such as inspection reporting, quality gates, health dashboards, and code coverage metrics that anticipated many capabilities later associated with Qodana. He went on to create PhpStorm and WebStorm, bringing stronger debugging, type inference, inspections, and code intelligence to PHP and helping make the language ecosystem more tool-friendly, while also initiating the PHP Foundation. As product decisions became more complex, he helped establish JetBrains’ analytics platform to replace assumptions about user needs with measured behavioral data. Qodana emerged after a customer request revealed that JetBrains’ code-quality capabilities needed to be separated from TeamCity and made usable within any CI/CD pipeline. In an era of AI-generated code, Gopachenko argues that deterministic analysis remains essential for addressing complex concerns such as security, architecture, data flow, and lifecycle management through repeatable and auditable quality controls.

“Rewrite It In Rust” (RIIR) has evolved from an open-source meme into a practical migration strategy, driven by Rust’s memory-safety guarantees, competitive performance, and concurrency model, with adoption in major projects including the Linux and Windows kernels, Firefox, and Cloudflare infrastructure. Rewrites take several forms, including drop-in replacements, alternative tools with different design goals, and incremental self-rewrites, and performance improvements can be substantial, though they may result from modern redesigns as much as from Rust itself. The discussion notes practical obstacles such as large binary sizes, interoperability, platform support, team expertise, licensing choices, lengthy timelines, and the likelihood that rewrites introduce new regressions or security issues despite Rust’s safety features. Examples of abandoned or reversed efforts, including projects involving Prisma, Loglog Games, and curl/hyper, illustrate that Rust is not universally appropriate and that other languages may better fit particular ecosystems or workflows. The recommended approach is to evaluate whether a project has meaningful memory-safety, reliability, performance, or concurrency needs, favor gradual integration over full replacement, and use extensive compatibility testing to reduce risk.

IntelliJ IDEA 2026.2.1, the first minor update to the 2026.2 release, is available through the IDE, JetBrains Toolbox App, Ubuntu snaps, and the JetBrains website. The update fixes several issues, including incorrect execution ordering for shell scripts in Markdown, Undo behavior after automatic import optimization, terminal session restarts when moving tabs after using Move to Editor, Mercurial conflict-resolution exceptions, and Java formatting that did not properly honor Smart tabs settings. Additional resolved issues are listed in the release notes, and users are encouraged to report new bugs through JetBrains’ issue tracker.

WebStorm 2026.2.1 introduces Chrome DevTools Connect, a bundled Chrome DevTools CLI skill that allows AI agents to interact directly with Chrome from within the IDE. Following the earlier Figma Connect integration, which brings design specifications and tokens from Figma into WebStorm, the feature completes a design-to-code-to-browser workflow intended to reduce context switching. After a one-time package installation, agents can open pages, inspect rendered interfaces, review console logs and network activity, take screenshots, and interact with browser workflows to reproduce and verify fixes. The announcement illustrates its use with a checkout bug involving stale prices after cart changes, where an agent can independently navigate the required steps, identify a missing dependency, apply a correction, and confirm the result in the browser while the developer remains responsible for decisions rather than manually relaying browser observations.

JetBrains .NET Day Online 2026 is a free one-day livestream event scheduled for October 7, 2026, with sessions held in Central European Summer Time and recordings available afterward. The program will include a JetBrains .NET team keynote, a live panel with product managers and engineers, interactive chat participation, and practical community presentations on .NET development. Unlike the prior two-day event, this edition will run for one day and has opened its call for speakers earlier, accepting proposals through September 4 via Sessionize. Organizers seek actionable talks, particularly on AI-assisted .NET development based on real project experience, while welcoming both experienced and first-time speakers from underrepresented parts of the community. Registration is expected to open in mid-August, with the full agenda and speaker lineup to be announced later.

JetBrains Academy’s July digest highlights new learning opportunities, community events, and discussions about programming education. It promotes Ardit Sulce’s Gen AI Engineer Bootcamp, which offers free PyCharm-based practice for building AI applications such as coding assistants, RAG tools, automations, image-aware apps, and voice assistants, alongside a new pandas course on Coursera that uses IDE feedback and includes projects involving TED Talk recommendations and LLM cost analysis. The digest also marks Kotlin’s 15th anniversary with free access for new Hyperskill users to its Kotlin catalog through October 9, previews the free IntelliJ IDEA Conf 2026 on September 8–9 with sessions on Java, Kotlin, AI workflows, tooling, and performance, and features an interview with Python Software Foundation director Sheena O’Connell on the continued importance of fundamentals and project-based learning in the age of AI.

JetBrains reports active and attempted exploitation of CVE-2026-63077 against unpatched TeamCity servers and urges customers to immediately upgrade to TeamCity 2025.11.7 or 2026.1.3, or install the available security patch plugin for versions 2017.1 and later if an upgrade is not immediately possible. The unauthenticated vulnerability can be exploited through the agent polling protocol by attackers with HTTP(S) access, potentially allowing arbitrary operating-system command execution under the TeamCity server process and exposing data, credentials, configurations, build artifacts, and downstream CI/CD pipelines. Administrators are advised to investigate server logs for ConversionException messages, which may indicate attempted or successful exploitation, and ForbiddenClassException messages after patching, which indicate blocked attempts; they should also review unauthorized build agents, especially those named with the prefix “scan.” TeamCity Cloud customers require no action because mitigations have already been applied, while self-hosted users unable to patch promptly should restrict external access and adopt longer-term measures including trusted-network access controls, minimum server privileges, VPNs or additional security layers, and separate hosts for TeamCity servers and build agents.

Figma Connect for WebStorm, available in WebStorm 2026.2.1, integrates Figma design files directly into the IDE to reduce context switching and improve design-to-code accuracy. Through an automatically configured Figma MCP connection, developers can browse layers, synchronize selections between WebStorm and Figma, and attach selected design nodes to AI chats without adding screenshots or full design files to the context. AI agents such as Junie, Claude, Copilot, and Cursor can then use the actual design specifications, component variants, primitives, and internal design tokens to generate code better aligned with an existing codebase. JetBrains describes the feature as the first stage of a broader effort to keep designs, code, and running applications visually aligned throughout development.

IntelliJ IDEA 2026.2 enhances its logpoints, positioning them as a more capable and faster alternative to traditional println debugging for developers and AI coding agents. Logpoints can log expressions without modifying source code and support conditions, stack traces, hit counters, caller filters, grouping, persistence, and navigation from console output back to the originating code. The release replaces debugger-side evaluation for eligible conditional and logging breakpoints with direct code instrumentation, avoiding repeated application suspension and delivering internal benchmark improvements of roughly 30 times in hot or timing-sensitive paths. New interfaces simplify manual logpoint creation, while bundled agent skills allow AI assistants used through the IDE, terminal, or external tools to create, manage, run, interpret, and clean up their own logpoints without altering a developer’s existing breakpoints. These features work in local and remote JVM debugging sessions and aim to make lightweight logging reliable for diagnosing issues such as timeouts, race conditions, and latency-sensitive failures.

Drew Penrod, a full-stack software engineer working as a DevSecOps engineer, discusses his experience integrating Qodana into his team's workflow at a company producing kid-friendly phones. The primary challenge he faced was maintaining consistent code quality and security across multiple repositories and languages, which was previously managed through manual code reviews and inconsistent automated checks. Qodana was chosen over other tools for its comprehensive capabilities in static analysis, dependency scanning, style coverage, and license auditing, which integrate seamlessly into both IDEs and CI pipelines. The incremental adoption of Qodana has already improved visibility into code quality and security issues, although full enforcement through soft and hard gates is still in progress. The tool has significantly enhanced the team's ability to manage compliance and security processes, making issues and vulnerabilities more visible and actionable across the development pipeline.

Java Annotated Monthly’s August 2026 issue curates July’s Java ecosystem news, tutorials, and community discussions, featuring Java Champion and Eclipse Collections creator Donald Raab. Key themes include preserving Java’s history through the official Java documentary and Duke’s Corner podcast archive, improving memory efficiency by reducing allocations before tuning garbage collectors, and updates spanning Java performance, ZGC, virtual threads, Valhalla, security releases, Jakarta EE, and developer tooling. The issue also surveys Kotlin’s fifteenth anniversary, new Kotlin libraries and AI benchmarks, the growing role and limitations of AI-assisted and agentic software development, and developments in Spring, Quarkus, Kubernetes, and local LLM tooling. Additional coverage highlights developer culture, upcoming IntelliJ IDEA events, and IntelliJ IDEA 2026.2 features, including expanded Java and Kotlin language intelligence for VS Code, Cursor, and agentic workflows.

JetBrains will host a free online Go 1.27 Release Party on August 25 at 4:00 pm UTC, streaming from its Amsterdam office as a community-focused event called The Blue Gopher. Hosted by Go developer advocate Ainsley Clark and principal engineer Jesús Espino, the livestream will feature Go team members Robert Griesemer, Alan Donovan, Marc Dougherty, Cameron Balahan, and Go contributor Joe Tsai discussing the release’s language and tooling updates, answering live questions, and reviewing early community reactions. Topics are expected to include generic methods, improved generic type inference, development tooling such as gopls, and GoLand’s immediate support for Go 1.27 features, with live demonstrations intended to help developers begin using the release.

JetBrains’ ReSharper extension version 2026.2 aims to make AI-first editors such as Cursor, Google Antigravity IDE, Devin Desktop, and Kiro more practical for professional C# and .NET development by adding a full .NET debugger alongside existing code intelligence features. The extension is positioned as an alternative to the common two-window workflow in which developers use an AI editor for code generation but rely on a separate IDE for debugging, testing, navigation, and refactoring. ReSharper combines static analysis for identifying issues in AI-generated code with code navigation, refactoring, unit testing, and debugging within one editor, and it offers a 30-day trial upon installation. It is available through Open VSX for compatible AI-first editors and the Visual Studio Code Marketplace for VS Code, while JetBrains is seeking community feedback and reviews to guide future development.

The month of July marked significant milestones and updates for the Kotlin programming language, celebrating its 15th anniversary with community engagement activities and the introduction of a public benchmark for AI coding agents, which evaluates performance across various engineering tasks. Kotlin 2.4.10 was released, featuring bug fixes, while the Kotlin 2.4.20-Beta2 introduced enhancements like coroutine stack trace recovery and expanded Swift export. Kotlin's integration into BlueJ 6.0 aims to facilitate its use in educational settings, enhancing students’ learning experiences. The RevenueCat Shipaton 2026 event encourages developers to showcase their Kotlin skills by building new apps, with opportunities to win the Ship Kotlin Everywhere Award. The Kotlin community also celebrated individuals contributing significantly to education and community building through the Golden Kodee Community Awards. Additionally, X has fully rebuilt its Android app using Kotlin, showcasing the language’s growing adoption, while JetBrains IDE users can now link their experiences to LinkedIn profiles via a new plugin. The roundup also highlighted the evolution of Kodee, the Kotlin mascot, alongside the spotlight on KMP libraries Ktor, Koin, and Kermit, which support networking, dependency injection, and logging, respectively.

JetBrains has announced the availability of IntelliJ IDEA's Java and Kotlin intelligence in a preview extension format for third-party editors such as VS Code, Cursor, and others, leveraging the Language Server Protocol (LSP) to enhance development experiences across multiple platforms. This move caters to the growing trend of agentic development, where developers increasingly rely on automated agents for implementation tasks and require only basic features like code navigation and completion from IDEs. The new extension offers features such as smart code completion, navigation, refactorings, and support for build tools like Maven, Gradle, and Bazel, providing fast and reliable performance even for large projects. During the preview phase, the extension is free, but post-preview it will require an IntelliJ IDEA Ultimate subscription, allowing users to access these capabilities in various environments. JetBrains is also working on supporting agentic, terminal-based workflows and invites user feedback to refine the extension towards a stable release.

dotInsights is a JetBrains newsletter providing updates on .NET and software development. It explores the historical roots of programming syntax, such as the use of semicolons in C# derived from Algol, and offers a variety of insights into .NET-related topics like nullable GUID route constraints, closed class hierarchies, and performance myths in EF Core. The newsletter discusses the latest tools and updates from JetBrains, including the release of dotUltimate tools 2026.2, ReSharper for Visual Studio Code with the new debugging feature, and Hot Reload for WPF, while also highlighting upcoming events like the annual gamedev day. Additionally, it includes community contributions, covering topics ranging from C# tips to open-source projects, alongside fun segments like developer puns and a creative project combining Doom with MS Paint.

Over the past six months, JetBrains has experienced a significant increase in AI development expenses, driven by a surge in the adoption of AI tools, leading to a roughly tenfold increase in costs. This rise was attributed to the introduction of new models like Claude Opus, which improved agent performance and were widely adopted by JetBrains developers in various environments. To manage these escalating expenses, JetBrains explored several solutions, ultimately developing the JetBrains Central CLI, a tool that enables developers to use AI tools seamlessly while allowing managers to monitor and control AI usage and costs effectively. This solution, which was rapidly deployed, helps in balancing developer freedom with cost management, offering granular control over AI limits and integrating usage data into a centralized console for easier governance. Despite rapid adoption, JetBrains continues to refine its policies and expand support for more agents while acknowledging the need for further enhancements to accommodate diverse workflows and consumption patterns.

JetBrains Academy offers a course titled "Mastering Python Libraries: pandas," designed to equip learners with practical skills in handling data using the pandas library, a crucial tool for data cleaning and manipulation in Python. The course is structured to provide hands-on experience through real-time feedback and error highlighting within an IDE, focusing on essential tasks such as sorting, filtering, and summarizing data. Participants will complete two portfolio projects, including a recommendation model using the TED Talks dataset and an analysis of compute costs for training large language models. The course is available in two formats: a comprehensive package on Coursera with video lessons and certification, or a free coding-focused option directly from the course catalog, allowing learners to choose based on their preferences for structure or self-driven exploration. It is recommended for individuals with basic Python knowledge, while prior experience with NumPy is beneficial but not mandatory.