Build1 distinct publisher3 min readPublished
JetBrains has pointed the next four months of CLion at embedded and agentic debugging, with the debugger config itself becoming a JSON file you can edit by hand, hand to an agent, or import from VS Code.
The Engineer · Build desk
Compiled by The EngineerSomething wrong?How this is made
Debug profiles arrived in CLion 2026.2 as a way to configure and switch debuggers [15]. The next release adds a JSON form of the same thing, editable by hand or with an agent's help, exposing more configuration options than CLion's UI currently does [16]. The second half of that is the load-bearing part. The UI stops being the ceiling on what a profile can say, and the profile becomes a file you can check in, diff and review. It also gives an agent something to type into, which a modal dialog never did.
The import path is the cheaper half of the same feature. A team can bring an existing JSON debug configuration across from VS Code and get the same debugger settings without reconfiguring from scratch [17]. Whether that saves you anything depends on whether the fields you actually use in a launch config have equivalents in the profile schema, and nobody can check that until the schema ships.
The HardFault skill is aimed at a real gap rather than a demo. HardFault_Handler usually catches the fault and tells you nothing about what faulted [6]. The answer sits in the CPU state at the moment of the crash: registers, the stack frame, the fault status registers, sometimes disassembly [7]. That read is precisely what embedded teams script for themselves. JetBrains plans to hand the same reads to an agent, which gets memory, register and disassembly views on top of the stepping and breakpoints already exposed since the MCP debugging feature shipped [10][8].
For that to transfer to your bench, three things have to hold. Your target is an ARM Cortex-M part, since that is the fault the roadmap describes [5]. The crash is reachable with real hardware attached, which is the workflow the skill is built for [11]. And your agent is one the IDE can detect, offer and launch in the terminal, which is how the setup-assist flow is specified [12].
Order matters more than the feature list suggests. The skill is planned for a future minor release, and the minors are the 2026.2.x line [9][1]. The JSON profile is for the next release, 2026.3 [16][1]. Minors land before the next stable, so the agent gets the crash-state tools some months before it gets the config file it could write [1]. Handing a whole embedded setup to an agent in one pass is two hops, not one.
JetBrains labels the roadmap preliminary and says it cannot guarantee every listed item will be implemented in CLion 2026.2 [4]. The hedge names 2026.2 only, while the stated window also covers 2026.3 [2]. I read that as a hedge on the near half of the list and silence on the far half, which is where TRACE32 and QNX sit in the highlights [3].
If I ran an embedded team, the in-house artifact I would stop extending is the fault triage script. The peripheral viewer is the other candidate, since the DAP work names a peripheral view alongside RTOS thread and FreeRTOS object debugging [14]. What I would keep is anything that runs in CI with no IDE open, because none of this is specified to work there. LLDB 21 on Windows and a GDB update on all platforms are in the same window, and they are plumbing rather than strategy [18].
Ranked by verification strength, evidence, and original report placement.
The new HardFault skill is planned for a future minor release and will be tailored to embedded systems prone to hard faults.
For the next release, JetBrains plans to let users save a debug profile as a JSON file and configure it manually or with the help of an AI agent, providing more configuration options than CLion's UI currently exposes.
JetBrains's CLion roadmap post covers updates planned over the next four months, in the upcoming minor releases (2026.2.x) and the next stable release (2026.3).
JetBrains says it decided to focus the roadmap on improving agentic workflows, embedded development support, and the debugger.
The roadmap highlights are: an AI skill for HardFault debugging; debug profiles with JSON configuration support and a customized TRACE32 profile; LLDB 21 support for Windows; and support for QNX projects.
JetBrains states the roadmap is preliminary and that it cannot guarantee every issue or feature listed will be addressed or implemented in CLion 2026.2, and that priorities may shift.
Follow any of these and your For You feed starts watching them — no settings page required.
Evidence-backed comparisons of source perspectives and observed adoption signals. Read the methodology
Which Builder, Operator, and Investor concerns the observed source mix emphasized—not a truth score.
Evidence, demonstrated adoption, hype gap, incentives, and confidence are assessed independently, each on its own current evidence. How these are measured.
First-party roadmap, no external corroboration
The cluster rests on exactly one source: JetBrains's own CLion roadmap post. That makes the announcement facts highly reliable as statements of intent — the focus areas, highlights, feature descriptions, and version numbers are quoted directly — but every forward-looking item is unshipped and carries the vendor's own no-guarantee disclaimer. There is no independent reporting, no issue tracker reference, no dates, and no measurement of any claimed benefit.
Predecessor features shipped, no usage data
Adoption evidence is limited to vendor-disclosed shipping milestones for the groundwork — debug profiles in CLion 2026.2, MCP debugging in the previous release, and DAP support added last year. Nothing in the source reports how many users or teams actually use those features, and the headline items (HardFault skill, JSON debug profiles, TRACE32 template, LLDB 21 on Windows, QNX support) have not shipped at all.
Plan framed as an accomplished shift
The underlying source is fairly measured — it labels itself preliminary and describes JSON configuration as an added, more flexible way to express debug profiles alongside the existing UI. The surrounding framing runs ahead of that: 'moving debug configuration out of the UI and into a JSON file' overstates a plan to add a JSON representation, and JetBrains's own 'will make it easier to develop and validate embedded projects with real hardware attached' is an unmeasured benefit for an unreleased skill. Modestly positive, not egregious, since the concrete artifacts (version numbers, feature descriptions, release channels) are all stated in the source.
Vendor marketing its own commercial IDE
The single source is a promotional roadmap post published by the vendor that sells CLion. JetBrains benefits directly from positioning the IDE as the place embedded and agentic C/C++ debugging happens, and it controls which items are highlighted, how benefits are phrased, and what is left out (dates, agent compatibility, pricing, security implications of agent access to memory and registers). No countervailing or independent voice is present in the cluster.
Announcement solid, delivery uncertain
Confidence is high that JetBrains said these things and that the already-shipped groundwork exists, because the source is primary and specific. Confidence is much lower about outcomes: single-publisher cluster, explicit preliminary disclaimer, no dates, no adoption or effectiveness data, and derived sequencing that rests only on release-channel labels rather than announced timing.
build
Amazon Q executed code from any repo you opened, and it is not the only one1 distinct publisher
build
JetBrains ships its OpenTelemetry plugin to four more IDEs; instrumentation is still your problem1 distinct publisher
build
Spline V2 turns the 3D editor into an endpoint, with the desktop app as the only door1 distinct publisher
build
One MCP command, three JSON shapes, and a failure mode that never errors1 distinct publisher
Distinct publishers with included, body-backed reporting in this cluster.
1 article · August 27, 2026