JetBrains reports revenue growth, net financial loss for 2025
helgilibrary.com
helgilibrary.com
I've tried it, and it seemed fine, but not compelling enough to even spend the free usage I get with my All Products Pack.
The Jetbrains integration is nice, but if you rely on the tool you're probably not going to use the IDE much anyway.
I would like to see one more ide-integrated, like I think running commands like ‘grep’ with the shell is really for the birds (creates a risk that some other command line might be run, the wrong files might be accessed, all that) and rather there should be a specialized toolbox.
[1] … I reject vibe coding. Token costs be damned but I always like to have a talk before it starts like “I think…, maybe you should…, does this make sense?, do you have any questions for me before you start?” and later “what are you doing in the code in the selection?”
It is alright to get an LLM review on code I write myself, but getting extra tokens is expensive, and it was not clear if I could configure it to use one of the API keys I have from GLM, MiMo, etc.
I tried Air as well. It was alright, but I found it a bit more cumbersome to use then Pi. I tried configuring Pi to be accessed though ACP, but it felt like going through a hoop to have a worse experience. Then again, I am not someone that manages multiple agents in parallel, at most I have one agent implementing something in a different repository while I am doing my own things.
Air could maybe be useful for me if I could plug in the LLMs I actually use directly, it is too tied to ChatGPT, Claude, etc.
Junie is boring, and that's perfect (for me).
I still use Visual Studio in my day job, where Claude's output while VERY helpful, requires my ownership of everything, meaning I am inspecting every single line it changes. If a change is bigger than I think it should, I kill it before I commit.
I know I don't HAVE to use an IDE for that, but if the change is small enough, I am faster than asking Claude to understand the subtext behind my personal context of the product, and the IDE is supremely helpful for making a quick change across a handful of files.
> ...inspecting...
I got used to sublime merge to context-switch editing vs reviewing, staging changes line-by-line
I think this is changing fast. Pressure is increasing on devs for output, and most devs I know are no longer inspecting lines. I have devs in my business unit who claim to not have looked at code for months, except on certain rare occasions. I am not a developer and this week I've been given access to the repo to build my own apps and extensions. There's a "review" between commit and deploy, but there's no chance the Tech Lead can manually review everything, so that's getting done by AI too.
I know this horrifies a lot of devs, but these tools are shockingly good and we are not seeing an increase in bugs. In fact our automated detections (also AI assisted) are reducing the number of customer reported critical bugs.
I really think the days of inspecting every line are over.
I agree that they have gotten shockingly good. It's been a long time since I've seen them do something that is objectively wrong. Once we get closer to the "too cheap to meter" cost level things will change radically again.
It is. I have seen Claude chasing after endless amount of edge cases that are just irrelevant in real usage especially for the kind of users we are supporting. At some point you need to stop reasoning about all those cases because it has zero benefit.
I have seen millions wasted because someone trusted an ai scripts calculation of a metric from the bottom of the org that led the top of the org to make a wrong decision only to laugh about ai. There is value but ffs read the god damn code. You can have the cake and eat it too. If the volume of code is so large you cannot read it, maybe it isnt worth shipping?
Or are you one of the ones pushing the real code reading on to others which seems to be common. Yes i can have agents vibe out 10 features and have my coworkers suffer fixing it in reviews.
What IS useful are the AI reviews. They catch bugs, not all are bugs but they do catch some. It is almost like they are better at finding logical issues across millions of tokens but not good at writing streamlined logic.
The number of times ai gives me a 800 line dif only to replace it with a 5 line dif after i read it and notice it grossly overcomplicated the ask and scoped in a bunch of nonsense from training data.
Basically they give you a way to view the code the llm has generated/changed easily, annotate that code for the llm, and manage multiple agents and at once.
> I am inspecting every single line it changes.
Honestly, when I'm looking at ClaudeCode's output 75% of time i'm doing it to learn and understand and not just check for correctness. I'm confident enough to admit I don't know everything and I've learned a lot from reading Claude's code.
Heavy user of WebStorm and Datagrip since at least 2019.
The anomaly is the cash flow of investing activities, which is not something you can put such activity as you have described under.
Reads like aimlessly burning whatever they felt they were able to burn without existential risk on some "also ran" LLM sinkhole.
In other words: nothing to see here, same as everybody else.
To do nothing is to die. I've been a JetBrains subscriber for over a decade. Nobody is going to use their tools in five years. I certainly don't need my subscription anymore.
> on some "also ran" LLM sinkhole.
They can't do Junie. It's a dead end. They can't do the same thing everyone else is doing either, or they're exactly as you put it: an "also ran" in a very crowded field.
The only way for JetBrains to survive is to figure out their Garmin play. They either find some niche within the existing product or - maybe (and very improbably) - they can innovate something wild nobody else has figured out yet that provides a path to new fertile pasture. But that's more the startup path than the thriving incumbent facing innovator's dilemma path.
But no matter what, if they stay the course, they're dead. Just like half the people expecting to still be writing code by hand.
I know this is not your main point, but common.
If this is true, AI would be the first tech impossible to learn 5 years after it appeared.
How many people out there can do hand lithography to make an 8086 to bootstrap computing? One?
What does THAT have to do with whether people who dont use AI today will die soon? What does "hand lithography" have to do with literally anything here?
VSCode has been eating at their users for years now. Jetbrains tools still were much better in my opinion but they are competing with “free” and “good enough”. With AI getting better, the main advantages of Jetbrains are gone.
I don’t need a massive IDE anymore. I still need an editor, but there’s hundreds of better tools for quick edits than a massive IDE.
It’s a company at the end of the day, but I hope they find a niche or pull a Garmin play like you said, otherwise I don’t see them being relevant.
What will replace it? The dumpster fire called Eclipse, certainly not. The even larger dumpster fire that is Electron based VS Code, also not. And "vibe coding", "agentic AI" etc. will also be a thing of the past once the VC money spigot selling tokens for far below actual cost dries up.
The JetBrains portfolio is here to stay.
(One might even see a total ban for American products in the EU or a significant push in sovereign technology on the horizon, and JB stands to profit from both options!)
In the devops/sysadmin world my stack would be common, and mostly people pick an editor and stick to it. I've been using Emacs for the past 20+ years at this point, and the last time I used Microsoft's IDE was back in the day when I was writing desktop apps using MFC (which probably dates me pretty well!) with visual studio.
I've seen colleagues use anything from atom, vim, emacs, notepad++, and other generic editors whos name I didn't recognize. There are one or two instances of VS Code I see now and again, but they're the outlier rather than the norm in my professional life.
They should stay in where they started, dev experience and IDEs custom for each language. Entering the AI coding was a mistake in my opinion, I’m sure one can argue that AI coding would have better tooling without their IDEs, but AI coders (Cc and codex) don’t use IDEs anymore so it’s a lost battle before the start
Sure. I still use mine though; privately and at work.
> Nobody is going to use their tools in five years.
> they're dead. Just like half the people expecting to still be writing code by hand.
Hyperbole much. Leave it on LinkedIn man.
Who knows?
5 years is a long time.
They're trying to navigate the AI era just like everyone else.
You know what we got told at work? “Scrappy AI startups are snapping at our heels, we need to move fast so the competition doesn't over take us”
…but if you ask: what startups? Silence. If you ask, why are we scared of some teenager vibe coding a platform and stealing our customers? Silence.
Dont question the narrative.
Of course AI is an existential threat. Of course there are vibed startups trying to eat our market.
Have you not seen our share price?
Such hyperbolic BS. Ffs. Calm down.
I could not care less about "new paradigm" editors, UI reworks and AI lock-in offerings, the only AI I want is let me bring my own local model, or interface with claude / codex / ...
Integration with other developer tools, code reviews etc. are better than ever. Ideavim is probably the best vim plugin and it gets new features every month. They are also investing a lot in the AI.
I would bet they will survive just fine unless we would write software in slack only using emoji :-)
Can't agents just use a language server? There are already a bunch of projects that provide this, e.g.: https://www.agent-lsp.com/
Doesn't seem like a huge differentiator anymore?
I don't really know much about their current users, but from a business perspective, post-tokenmaxxing and them having an IDE, it seems like the most efficient environment for having a human in the loop is something they could tackle?
But until language servers, IDEs with built-in code analysis had a huge advantage. This stopped once LSP was designed and some language servers got mature. LSP was developed originally by VS Code and it is easy to see why - it allowed VS Code to compete with IDEs without writing their own code analysis by letting language developers write a standard server. This made VS Code (and others like Zed) so powerful, that they had already replaced IDEs for many users (maybe outside Java). LLMs are just another nail in the coffin.
If you use ideavim you can enable feature which shows you action ID you have currently triggered (Ideavim: Track action IDs). If you click on anything it will show you name of that action and you can setup vim shortcut for that. This way, you can use almost anything by just typing a few letters. But that is just a start.
Now imagine you can use this to create "macro" which will create something like skill for LLM. So in a few seconds to minutes you can create "skills"/runbooks for major refactorings, project updates, git bisections, project deployments, log analysis or whatever you can think of. You will just click on 20 features and it will record what you did with some additional context (files, connected services, build systems etc.). This is the strength of integrated tools.
Of course this is just my imagination but I am not the smartest person in the world and I am pretty sure/hope that someone in jetbrains or in other IDE company is thinking this way.
I think that world is farther off than you think, especially in critical line of business software. You can YOLO it with your internal dashboard or your hipster coffee review site, but in my 2M-line highly regulated banking system, humans sign off on the code - even if LLMs do most of the typing.
No, it didn't stop. In my experience, LSPs are still incredibly poor and comparatively primitive vs the actual analysis that JetBrains have implemented. It's night-and-day different in terms of the supported refactorings, actual understanding of the types and the codebase etc.
Also, LSP is just poorly designed and inefficient. JSON-RPC was an awful choice, the specification text is not well-written and the whole thing feels like a Microsoft pet project for VS Code than an open specification that everyone agrees works well.
Not many did that because JetBrains never cared much to properly document this path, and so using LSPs is a better paved cowpath. But that's because IDEs aren't a real business for Microsoft, whereas they are for JetBrains, and we know where that leads - the landscape is filled with the skeletons of dead IDEs that were just loss making corporate side projects, defunded and "donated" to some foundation once the executive sponsors moved on. NetBeans and Eclipse are two of the most obvious but there have been others.
The risk with VS Code is it goes the same way. Eventually Microsoft needs to cut back, perhaps due to needing more capital for AI or due to AI related losses, and in the general layoffs that follow VS Code gets cut back to a skeleton crew.
And yes, there are people who use vim in a screen session, but I don't fit into that category. I like my GoLand IDE.
And while there are a ton of IDEs out there, I use what I'm used to.
Yeah, no, vast majority just want to pick a AI vendor and integrate it into their IDEA or CLion or whatever other editor they were already using. Pushing into entirely different subscription was dead on arrival.
They figured that out and started integrating it into main tooling (https://plugins.jetbrains.com/plugin/33314-air), but they definitely wasted a bunch of resources on something nobody really wanted.
Maybe people smarter than me know better but couldn't there be a middle ground where an IDE/Editor has an embedded engine (doesn't need to be a full-on LLM) that doesn't require external tool calls and token spend?
If an organization is paying $2400/year per developer for tokens and a highly intelligent editor/IDE comes around that charges $1000/yr and gets more output at a fixed cost, its a no-brainer of a decision.
I'm using the word understanding loosely there, but I couldn't think of another word.
It just so happens that there's no framework (outside silos) for many specific tasks, and AI is the workaround to surface those patterns.
Intellij when I used to use it had a lot great features like refactoring, extracting part of code as a function, renaming and creating empty classes/boilerplate but that's it
In current job I can order LLM to take data sink from other endpoint and write new with given URL. It will fetch from endpoint, check what it gives, compare with other and write new sink. Then it needs polishing because it always create something as awful as possible with cloning data all around but the most boring and soul sucking part is done
They can typically explain the history of something faster than any human
But finding out what an LLM needs to understand from a business side to write your code good, is an otpimzation which no one cares currently.
I'm pretty sure we either stay on big full frontier models for a long time, just use them for everything or we will start to see more and more people doing finetuning/project specific training like java + german + english + business contxt xy;
It will be an indicator for the whole industry.
Qwen3.8-Flash-Next - relatively small, it runs on 6 6 year old GPUs on my home PC happily running 5 simultaneous 262k sessions with additional 10 cached in RAM (bought back when you didn't have to remortgage your house for Ram) and it has been the first local model that is not a toy.
But there is a class of problems where I still reach for Anthropic's fable...
However, I have a hunch bordering with certainty Anthropic is achieving such great results by doing a lot of harness tricks.
For example opus 4.8, is not much better on coding than before mentioned Qwen model, but gets amazing results on factual knowledge stuff (the knowing all works of Shakespeare thing). How hard would it be to add a general knowledge RAG to requests that contain relevant questions and beat all benchmarks like that? Not very hard.
So I think there is big innovation to be had in harnesses, routers, inference and so on.
As to money spent on AI per developer my current client (a fortune 200 software company) spends $500 per month. That is $6k a year. A lot more than your examples. And many people run out of their quota pretty quickly.
That's what, the same as a Mac studio?
I do not enjoy the fact those cards cost more than their msrp 6 years later, but there is a much more important consideration than money (which also makes sense, but about that later). It is the fact soon people will not be able to do my job without AI at all. Even now if I didn't use it I think I'd be out competed very quickly.
And having the ability to run it locally, using a really useful, not toy model is very useful. It makes you independent from Anthropic deciding to ban your account for example.
As for money, it is an open secret the biggest cost of coding agents use is input tokens not generation. I tend to use about 1.3B input tokens per week on claude code with only 7-8M out. Out if this 80% is cached. And the cache is pretty restrictive. You have 5min cache and 1h cache. If you don't keep reading over that time your cache expires on the cloud. Then your 500k context counts as 500k input in its entirety.
And the numbers I mentioned would cost thousands of USD a week at API prices.
But when you control inference, you can keep your cache for as long as you want and save it to disk.
I tend to have up to 10 coding agent sessions open at a time. Some are used once a week. I never use more than 5 at the same moment. Having 15 full contexts cached in RAM basically moves my local cache utilisation to 95%+
Basically I think the AI companies will soon require us to pay the real price for the inference. I prefer to be ready.
This 6 GPU setup will probably outspend OpenRouter on electricity alone.
If all those nvidia gpus the hyperscalers bought were online the cost to rent a single b200 wouldn't be $50 and hour and you could buy those 6 year old gpus I use for $200 each. Not almost $2k a pop they sold for now.
A 180gb b200 on runpod is $6.8/hr. Nowhere near $50/hr.
The _most expensive_ on-demand b200 rental I can find is $11.2/hr. There's a number of websites around these days that track GPU rental prices across different services: gpus.io, gpu.watchworks.dev (vast and runpod only), gputracker.net (not free, lol), gpurentalprices.com, priceofcompute.com, rentgpu.org, etc (I'm only looking at the first page of search results for GPU rental prices tracker search). Most of these don't include vast or runpod, but all of them show prices under $10, mostly around $6/hr for b200.
I signed up with half a dozen providers that had such numbers on their main page. When I tried to actually rent one, every time no such instances were available or they were more like 5x what you mention at the cheapest.
Ergo 6 GPUs isn't a typical setup, never has been and most likely never will.
OP is a classic outlier dev who is able and willing to set up and maintain such a thing - most normal people aren't.
I have a home network consisting of multiple buildings, a server room with a k8 cluster and various devices, some Cctv cameras, redundant fiber links between buildings, ftth Internet and lte backup, and so on. Not a simple network. All on Mikrotik switches using a lot of modern features like L3 in hardware routing. All properly designed, servers are multi homed with 10G DAC cables between switched.
Occasionally I'd notice few second drops when observing Cctv from my cameras on the monitor attached to my pc. Pc on the 10G.
Also occasionally I'd get random devices (android TV) decide "it has no Internet) for a minute at a time.
Also occasionally I'd have my AI take 20s to answer when I know for a fact it is doing absolutely nothing.
First I looked into it myself and I found nothing. No misconfiguration etc. Then I used opus with it. It found no network drops on any interfaces etc. But it wrote a script that opened 10k connections, kept them open and sent traffic through them. This was tried to all my k8 nodes and one node would occasionally refuse to open 0.1% of these connections.
Opus decided it must be a network card or a DAC cable. It took ages to identify which. I replaced both, problem went away for weeks each time and then returned every time.
Opus had a bajillion ideas to mess with my network config. Thankfully I know enough about networking not to let it take me on a wild goose chase.
Then I used Fable. Fable took 5 minutes and found the server grade Nic card's driver I use has a known rare problem where in certain configuration the default memory buffers for some hardware offload feature are too small for it and when connections get opened rapidly it sometimes chokes.
But there are two nodes with exact same config. Why only one was affected? Actually both were affected, but on one it was so rare I had to run the testing for hours to notice it.
The memory was increased and the problem... Became a lot rarer. Not resolved completely.
Fable again. This time it came up with an idea there must be a bug in the active/standby part of the driver where it occasionally let's some traffic through the standby interface. Which makes the switches ARP learn the standby as the correct path to that mac and send a portion of that traffic there, but the standby couldn't receive traffic.
It setup tcpdump on both the standby and live and proved indeed it was happening. I do not remember how this was resolved, but it was and for last 4 weeks the problem is gone.
I have actual programming problems too. 4 of which I turned into a personal Ai benchmark. Only fable solves all 4.
IDEA already have small LLM for one line code completion IIRC.
But the gain people want from LLM is generally "here, add this entire feature" or "here, go thru every dependency's changelog and update code to work with latest version". Those are not small LLM tasks
Would there be problem domains in which the more educated LLM would perform better? Are your names directly related to concepts from said domain,
LLM comments: "I think it may be a potential bug that the sum VATAddedTax gets added to the TaxFreeItems".
I mean it seems a bit unnecessary but also maybe it can help in unexpected ways.
But I’m sure we can have a small model that’s really strong at programming concepts, JavaScript syntax, and that’s about it. You’d interact with it differently, at specific seams in your code base - review a PR, merge two functions together, investigate these logs.
Or maybe I’m just not adequately absorbing the bitter lesson. Idk
1. Storing Shakespeare's work costs almost no $ in regards to disk space.
2. If the prompt doesn't include "Shakespeare" or relevant terms then no regression is performed for that topic and therefore there is no effective token cost.
Someone may correct me, but I think it's not a big $ win to exclude relevant topics from the models' overall capabilities. Instead you'd tune weights so that #2 better identifies what is or isn't among the relevant terms on which to run regressions.
Meanwhile, a template (maybe a couple KB) costs less than a couple cents to store and run. Large Languages Models are not really interesting, (smaller) LLMs that only contain "what you need" are.
I don't see it. In every case my time is more valuable than the cost of the prompt (so far) so the higher dollar cost, one shot, "getter done" model is the better net value option.
This is especially true when taking into account that the crow doesn't just fail on a single prompt, it does something much worse. It creates new problems that need to be undone afterwards. It confidently duplicates, triplicates, etc. a damaging work output that then needs more and more work to clean up before starting over.
That's a trivial number for sharing between a small user base of, in my case, 150 employees.
What am I missing? You're talking about maybe $60k retail cost in high read speed SANs that are likely already in place for a business of this size anyway? (Probably purchased a few years ago for under $30k. At least mine are.) In a US data center I'm paying a flat rate for rack space, so power consumption isn't a consideration anyway, but honestly it really isn't that much power even if I was being billed for it.
It's really nothing. An overlooked line item on a budget sheet.
So the real cost if I were to self host is video cards. But as mentioned previously, that's not reduced by smaller data sets, it's reduced by better weighted models, right? Let me know if I'm mistaken, please.
I'm very interested to be persuaded otherwise as a decision maker. Thanks for your insight and ideas.
Considering all of the above, I'm currently of the mind that a lower cost model that makes more mistakes is much more expensive in net, actually. So I prefer the most accurate, better weighted model, not the slimmer data set.
If the implementation brief says "attempting a reconnect in this handler would be a wild goose chase", the model needs to know enough Shakespeare, at least indirectly, to understand that expression...
I don't think LLM needs to know Shakespeare to understand: "attempting a reconnect in this handler would be a wild goose chase." I would even bet that most people learned of this expression before reading Romeo and Julie.
func randomName () { desired machine physics }
Everything around "desired machine physics" is superfluous wank; historically a biz case stored as code when some UI could feed biz case params go a function generator
Come on we know what we use computers for; media consumption and 2D data entry/review. Locally we just need a core engine for geometric transforms of visual state. What all these languages give us ability to create such a generic VM filled with customized semantics that mean nothing to solving the problem but plenty to a clever coder.
Kind of like Unicode we need distilled geometry primitives like "teapot for text" and desktop metaphors and to let people put the superfluous wank at the presentation layer
Which text used to be so making UI out of layers of text, OOP, and such made sense for decades
But we're just engaged in bloating system state through def jargon_to_encapsulate { desired machine physics } when we already know it's going to be simulated 3D or 2D visual transforms. We don't need to capture all those states in code verbatim.
Things like Jev are the future of models. Fine tuned on transforms given a context. "So you want to replicate GTA5? Here's a data set of geometric shapes and gradients constraints from all observed xyz" pipe that into your local renderer
We're entering the phase of software engineering (and engineering generally) where we realized we been dramatically over playing the song and can strip out entire asides and digressions, circumlocutions of provenance, to tighten up pacing and improve enjoyment of the outcomes. Hopefully. Or we kill ourselves. Through social squabbles (political, economic, religious, whatever) due to laziness to learn etiquette, and environmental destruction.
Check this graph:
That's needed to interpret the 10000 monkeys typing requirements in the various corporate product roles /s
Probably not unless you're writing tooling relevant to literature or prose, but I can't imagine trusting jetbrains (or any ai studio) to curate this.
I also imagine it could be a big shakeup if all of a sudden models could run on CPU. Imagine running an Astra-level coding agent, locally on your laptop. All of a sudden GPUs wouldn’t look as valuable, if you don’t need them as much
We are still some time away from that, but it seems like progress is being made
What language do you plan on prompting it in?
That might be a bad example ... replace english with nearly anything not related to prompting/coding. For example, I bet the models have "knowledge" of biology, chemistry, etc. not exactly useful for programming a SaaS web app that say does project mgmt. I think there's opportunity for very specific tooling rather than "general" knowledge.
But even besides that... Yesterday I prompted a feature by referencing a specific Monty Python skit. Does the coding tool need to know Monty Python? Maybe I could describe the feature in other terms, but it sure was convenient to have this shared knowledge. I don't see why Shakespeare would be any different.
Turns out that actually - no. Researchers have managed to prune half the Experts in a MoE model that had a low probability of getting activated during coding tasks, resulting in a more focused model:
https://arxiv.org/abs/2607.16721
Main benefit is that it greatly reduces the amount of RAM required to run these models. Of course you could just cache those unused experts on disk instead, but the main point here is that you know which ones matter.
But aside from that recent models, like Qwen3.8-27b are reportedly more durable under heavy quantisation, e.g. 3bits or even ternary. With additional techniques like TurboQuant, you can feasibly run these models on consumer hardware - even if at 1/4th the speed you'd get from rented infrastructure.
VS Code has extensions such as Kilo Code or llama-vscode which let you work with local models much like you would with cloud based solutions.
My employer is spending $50,000/yr per employee on tokens, and they're not alone
And hopefully they are just paying that per developer, not per employee.
The same can be said about software engineers. The tricky thing is, it's hard to separate a subset of knowledge from the whole, for both human beings and LLMs
1: Local models are catching up quickly
2: Visual Studio Intellicode (not to be confused with Intellisense) was/is surprisingly good at suggestions (when it first appeared before people went over to CLI's I felt that it was almost magically good for it's time, turned off co-pilot and whatever backend for a reason of compliance for a local workspace and the suggestions are quite good still even if not on the same level as the frontier suggestions).
If it pans out, with their brand people many would probably be happy to fork over for a Jetbrains licence.
People are not going to stop using AI no matter what your concerns or feelings are.
...or they're bailing out of really bad investments before they become even worse ones...
I've always been a JB fan. But the last few updates have been quite rough, and they really don't seem to have worked out the AI thing at all.
Who has?
I’ve bought WebStorm every year but I’m getting a bit pissy about their focus on ‘the wrong thing’. The UI redesign feels not-quite-there-yet, DB introspection often fails, Deno support is barebones, etc.
No idea why they thought they can compete with frontier AI labs on that, it's entirely waste of money
They also tried to push AI feature set as a separate subscription which is just insane in current tooling market.
All users wanted is good integration of multi-AI providers in their base offering. I think they are slowly shifting to that but that's a lot of money wasted already
These companies see the interfaces with the customer moving into domains they lack the taste and capability to compete.
They want to own that channel even if it is to spam them with ads like BMW did with the Spider-Man “special feature.”
Or Chamberlain has (reportedly) playing with the location of buttons and ads in their “app.”
Rivian, BMW, Chamberlain have the market dominance to ignore what customers want.
Jetbrains does not but had / has to try.
They host a lot of models too, and that is probably where they burned the cash.
I love that I can use browse the code in it and inline my comments for my prompts and send out all my requests into a single prompt
Negative cash flow from investing means that some prior investment has been shown to be worth far less than they paid for it.
You're suggesting "investing" is like R&D?
Investing is when you buy stocks or bitcoin and hope. Except for 1 year, their "investments" have always lost, last year about 50% of total assets:
-908 -4,374 3,970 -1,946 -10,273
"Investing" is traditionally how money is skimmed: something's sold to a friend at an inflated price that only becomes recognized as such years later amidst some other cover/crisis (if not after a statute of limitations). The other option is sweetheart deals - unneeded property leases, jobs for friends, etc. - but those are a bit more traceable, while investments can have multiple shell-company layers and complex derivatives.
Now it's Claude Code and ever so occasionally Codex.
I never do work in IDEs by hand anymore. I stopped writing code entirely in February and I will likely never write code again unless my internet dies.
I need a JetBrains-level AST navigator that focuses on high level code navigation and understanding, and moreover on code and architectural review. I need to quickly scan diffs and quickly see architecture at a glance.
Of course even that too many eventually fall away.
I rarely open RustRover these days. I could never have predicted that.
I don't even remember the last time I opened them, I cancelled my All Products pack this year.
The advantage it had over vscode was always the better language features and the familiar UI.
None of that is useful to me in AI based workflows. Some might still disagree, but the manual development workflow using an IDE is clearly dying.
JetBrain's revenue will obviously crater as a result, particularly when slower enterprise licenses follow.
Half of HN hates AI.
A large percentage thinks that the current status quo is how things will look over the next decade. They don't think everything is fundamentally and irreversibly changing.
Nobody is coming out of this with the same career. The whole world is being rewired. Some people really don't like that.
I'm just glad we're out of the web platform / cellphone incrementalism era. I wish more of my career could have been spent with this rocket fuel. It's dangerous and hypergolic, but it's fun and flashy and capable of pulling us out of this gravity well.
That there is no lack of people delivering low quality using AI does not change this.
And as soon as an edge case pops up that your model will have never been able to hear about because it hasn't been released publicly, security vuln, whatever, you'll get a "fix" confidently hallucinated at you and be none the wiser.
There's going to be a huge pendulum swing with all the llm zombies and sanewashing it like this isn't helping anyone.
All of this just oozes junior engineer if you're even employed in the field at all.
It doesn't give you the right to insult my expertise, and frankly your arguments sound like things that one would make up despite little actual experience using AI to develop software.
That's probably the rare exception.
Even in finance everyone is using AI.
> there is no lack of people delivering low quality using AI
I like how you self-associate. Do you really belong to the first group, or is that what you think you are.
Most "developers" were busy cranking out low-end software before AI.
They never worked on large, complex software systems or in professional engineering orgs.
Lots of these people never would have made the grade, would have been cut, or forever juniors. Many were probably bitter about this.
Well now comes along AI..
And I don't use the debugger nowadays. The AI can do it much faster and add relevant instrumentation and parse logs.
I'm on the opinion that if it's "code review" and code is not properly checked out than it's just a meat linter phase that's almost completely useless with meaningless style disagreements.
On the command line it seems a bit tedious with forks, and disk space constraints in our crappy enterprise environment are another factor.
You are able to do this while the output is small enough. But, it will not stay small for long. Business expectations are rising fast. To stay competitive, you have to push large amounts of code/fixes/features. There is no way to manually review it or QA it. If your org is not there yet, it will eventually get there. Or it will die out. It is only a matter of time.
If you've been on HN long enough you recognize that the OP is quite prolific in making absurd claims about AI: infamously predicted that children would be making professional, Hollywood level films by the end of 2025, and is now spending their time building the 5000th barely functional clone of Adobe tools[0]. It's probably a little unfair, but they are bold claims from someone who really does not have the ground to be making bold claims.
The company has always been registered in Prague, Czechia.
They just moved the development center from St. Peterburg, Russia to Munich, Germany.
I firmly believe JetBrains would have a better chance of survival if they stopped chasing the AI hype and got back to work on their IDEs, accepting the fact that they'll have less users than before. Right now, they're completely lost.
If AI continues to be improving then it's reasonable to assume most people won't need a full blown IDE.
Wonder what the "something big" could be that companies are throwing money into in 2026.
Next year I am 95% certain I won't renew anymore.
IIRC investments are any transactions which increase the assets in the balance sheet. Losses are outflows net of inflows.
In abstract terms, one is about stock and the other about flow of spend.
Because traders are short-sighted and demand the profit line always goes up.
They're also horrifyingly risk-averse. A temporary dip in profit because money is being spent on expanding is a negative signal to them.
I regret someone convincing me not to buy TSMC stock about 5 years ago because of their high CapEx. I would have 5x'd my money since then.
Probably AI spend and increased developer cost (salary + AI subscription cost). And the increase in memory prices means procuring IT assets has sky-rocketed too.
I would assume the margins they operated on, evaporated with the AI bubble.
Yes. Companies have been looking at nothing but revenue for over 10 years now. You realize that a sustainable company has to look at net profit at some point?
Look at the report (or point your clankers at it), not the saased helgi-pay-me-for-more, but free, full at CZ corporate registry. few tidbits from my fast (error prone) readin:
- main reason of net income loss is currency movement in 2025(CZK vs USD). eg. if they hold USD, they report loss without money moving. The other was bigger costs (but look below)
- they have 6% rev growth but ONLY in this CZK entity, whole group is whooping 25% up
- investing was lending (to subsidiaries) and outflow to bank deposits (sic!)
- cost increase impacting operating profit was from:
- “Other services”: +1,941, to 4,941.
- Consulting: +482, to 601.
- Marketing: +428, to 2,146
- Software development: -1,025, to 3,216
not yet ;)
Personally I usually use Claude inside the Jetbrain's IDE terminal, even if I code by hand obviously less. I still like using the diff, navigation, quick access to any file path for my prompt etc but maybe that won't last.
(edit: although I currently use an old perpetual fallback license because I didn't like the last price increase especially as they slowly remove what I like in the UI)
Nobody cares how I get there or how ugly the code is. They care how fast I can do it and how reliable the software is.
I look at code sometimes, in down time, to see what's been done terribly by AI, and to fix it and hopefully fix the process so that things don't get done terribly in that particular way in the future.
This shouldn't be normalized for you yet unless you're at a faang pushing this at the edge and new to the field, cause this isn't what we used to do 2 years ago.
If you're happy with the ai slop $$$ job more power to you but that isn't the entire field and there used to be (and hopefully still are) good and fun engineering jobs.
Contrary to popular normie belief, no not everyone wants to work at the Metas and OpenAIs and for good reason.
edit: Guys a literal business owner writing code for his own business, christ, what a waste of my time. So instead of hiring actual engineers you try to make it sound like you're employed as a software engineer and your experience is remotely normal. You are the literal business owner not filling seats because you're using AI.
"I'm paid to just shut up and code, baby!"
Yeah, that isn't a real SWE job, bud, don't make comments like you're in the trenches.
I still get to do some coding, where there are safety-critical production systems, but the work is mostly tooling that gets us to that point or supports the business otherwise.
It's an awesome job. Couldn't be funner, pretty much, except on data collection days. I get high level tasks, or come up with my own, and find or build solutions - no more running a whole business, doing production, keeping books, shipping orders, doing customer support - I only do the stuff I like.
The AI review stage is where I've found prompting matters a lot more than that initial prototyping phase. I've iterated on prompts and tooling that help the AI keep the codebase clean-ish.
Of course it did. Because reviewing code thoroughly is harder than writing it.
Writing only consists of "making sure it does the task", reviewer have to understand code first, check if it does the task, then check whether it doesn't affect something else negatively (and it can be meta things like "doesn't adhere to project style", even if technical side is correct)
If there's one thing that I learned from AI proponents is that they don't value correctness. They only want to write more code every day. Which actually baffles me, because for a given feature set, there should be a Definition of Done, and the only work left should be slight alterations for oversight and dependency updates.
I spend ~10-20 tokens on correctness and codebase cleanliness for every 1 I spend on new features.
Vibes.
Reviews take way more time than new features, and often utilize 3 subagents at a time - it's not uncommon to have reviews take 3 hours when the feature only took 15 minutes. The numbers here are just estimates, though - I don't keep track. "10x to 20x tokens on review" is probably underestimating review cost, if anything.
I don't review all code myself, but I do spend down-time reading code. When I find obviously bad code/patterns/whatever, I don't just fix it directly - I work to create automated tests (like static analysis, almost) or adjust or create prompts and tools for agents (either for review stage or initial implementation) to solve that class of issue, instead of just that instance of it.
I never review the first iteration. I review it after the agents have already poured a ton of time into it, if ever.
I do sometimes watch agents work, and redirect them if I see them doing something dumb. But, usually, I have 5+ agents running, not counting sub-agents, and I'm just messing with the apps myself to find the next feature to create or polish.
They've also done so many pivots on AI, all of them weakly and annoyingly done. They couldn't even pull of FiTM copilot well, they were super late on it and it had all sort of bugs.
They could have just taken the loss and written an amazing GUI coding agent that integrated well with their IDE -- amazing integrations with their refactorings, etc. -- but that played well in other people's ecosystems but they refused and tried to own the whole pipe. Or something. They just confused me.
Their latest attempt is to allow you to connect to and run other people's agent harnesses inside the IDE and it works well enough but it wasn't enough to grab me since I (like you) use herdr on another machine to do the coding.
I've been using their products since ~IDEA 3.x. Almost my entire 25+ year career really. My fingers are wedded to their keystrokes.
Most recently they integrated air, which is basically an "agent management/orchestrator" where you can run any ACP-compatible agent with any model you want and it's just the single place where you manage them, see their progress, steer them, merge their results etc.
For their entire existence people have complained about JetBrains this way because they always face some competitor that isn't making money and isn't even trying. Eventually those competitors go down, but a new one instantly arises. People just really love losing money on developer tools.
Wanting to charge money for an AI service is a clearly sensible business move. If their competitors weren't shredding the world's entire supply of investable capital as quickly as possible, this would be a good strategy. Alas.
It only fits a hands-on, merely AI-assisted development approach, on one feature at a time, that is not typically productive compared to agentic development.
You might disagree, but you'll find that the proponents of the hands-on approach are losing ground every month as AI gets better at working autonomously.
Claude constantly makes poor architectural decisions, adds unnecessary and costly checks, makes wrong assumptions, etc.
Doesn't take the value out of LLMs writing code, but they need to be properly steered and reasoned with. How will you do so if you don't even browse the code it generates.
I always suspect that the people all in fully agentic codig like this are mostly creating prototypes, half-assed copies of existing products, etc.
I am glad to not work in such an environment.
I've put like 500 hours of work into it over the last 6 months, besides my full-time software engineering job.
Frankly I think I have more experience than most here at using AI.
For me it works very well to just have a conversation with the agent in order to understand issues and steer it.
Essentially I would ask the question I would otherwise try to answer by reading the code.
Obviously, this has the downside that sometimes you miss things that would be obvious when reading and understanding all the code.
Since that can take a lot of time, it is still more efficient for me to instead QA test functionality and address issues I notice during actual use.
This doesn't say much. Plenty mobile apps, even paid ones, are of shovelware quality. And even if that's not the case, it's typically something very self-contained and of relatively low complexity.
On my personal projects I also seldom need to review code very thoroughly. But it's also not super complex stuff.
At my workplace things are not like that. It's a very complex system on a highly regulated environment. Opus 5.5 constantly get things wrong in ways that are simply not acceptable.
And I am not even an AI naysayer. I accept it as another development tool.
Complexity is up for debate. The project currently has ~1500 en translations and 7 AI models I optimized for mobile.
I think the key point is being self-contained, so that QA testing is effective for catching issues.
If that's your goal, stop using the slop machine. You will never make something actually good if you are letting it drive.
There is potential to build a better UI than what's constrained within a CLI's grid of characters.
I still read all the code AI produces, and I have a specific workflow. I scaffold the API first using AI, then review it for quality. Then I write tests, and review them for quality. Implementation is last, and technically I need not review the code but I choose to.
When I’ve done agentic development, the only thing I’ve accomplished is 100x more token burn with lower-quality code. It’s also not faster, because the tokens cost time and so many mistakes are made that must be cleaned up. The agents burn so much time going around in circles, when I could’ve just steered the model to write a good implementation.
Keep in mind, this is very fast. Models still produce thousands of lines of code in mere minutes. And with tests backing them up and an API frozen, the model goes much faster as it can iterate and has a framework for what it’s doing.
Disclosure: I work on Xpoze.
I'm paid to create a product. If Claude does so without me having to look at the code, then that's what I'm being paid to do.
This of course varies by company but this is clearly where it's headed: bot pushes, bot reviews, you look at the PR title and click merge.
> What would you say... ya do here?
Your laughter is noted - but we have ever laughed about it.
I have seen a bubble sort function in a PR from an engineer with 10 years of experience. Meanwhile sort from standard library is easily available with one single line.
The bar has become as low as "it works" without considering what's in the code or whether the entire feature should even exist at all.
P.S. that same engineer sent out a PR of 200-file feature. The PR is so large that it freezes the latest MacBook Pro if you try to read it. Nobody reviewed it and he merged it himself. Nobody uses that feature, and nobody in the teams wants to maintain it. Now we are considering scrapping it.
Quality, maintainability, simplicity, understandability, flexibility etc all still matter at $DAY_JOB, where you’ve got paying customers. We’ve got a responsibility to write good software that adds to people’s lives.
I’d recommend to try to raise the bar. Commit messages written by humans, no PRs above a certain size, any PR needs an introduction / explanation by author first for the reviewers.
So it's already an improvement. Should it be manually read, comprehended, reviewed? Probably. But they can get to an improvement over what they did 2 years ago, with basically no effort. And then they can get a little bit further, with massive effort?
The "LLM-yolo" is a big knee in the cost/benefit curve. It's an improvement over their "old code". The only drawback is: it's still containing bugs, and now no one understands them. But that's not hitting them until that code has aged somewhat, so a year or two down the line.
If mediocre code is better quality than what you wrote by hand, you've quickly discovered that you're incompetent.
Most code I have seen and reviewed over my 25+ year programmer life has been no worse than mediocre LLM code.
It's not a massive sample, but to me it suggests, most code programmers write, is somewhere between bad and mediocre.
And here's the appeal of the models: if what you used to produced was bad-to-mediocre, and you can now do slightly better for much cheaper, that's a huge win.
And the guy you were responding to is seeing people produce worse code with LLMs (e.g. senior engineers pushing non-library bubble sort implementations, like they're in a high school programming class).
And if you're somehow right, it's not a "huge win" for you. It's a sign you're personally providing little value to the business, and sooner or later you'll need to find a new career.
Basically: the code was so bad before, that un-reviewed LLM-code is now better than the average contribution. That means, that at least short term, the vibe coding can increase quality.
The problem is that it also increases code volume (bad) and rapidly decreases understanding (even worse).
There is no system prompt that can prevent this. If all you needed was some kind of rather short instruction we'd already have that baked into harnesses a long time ago. The problem is not that agents do not have the right instructions, they theoretically have everything there is to know about software architecture already in their training data.
I recognize that crafting a 'perfect' prompt is impossible, but neither is writing the perfect code, or even the 'perfect' code style guide. But it is 100% the kind of problem that can be iteratively improved to a point where it's much better than what you get by one-shotting everything without much consideration of these details.
I myself am maybe 5% sophisticated if 0 is I just discovered LLMs today, and 100 is the most skilled at using AI the world has seen. What I've learned so far is that I have a lot of room to improve.
Which is why I am actually not completely worried about the careers of current software engineers: If you brought in a bunch of non-engineers to prompt Claude to build and maintain an ERP system, or a social networking site, or an ad exchange, or even Shopify clone, I don't see those products being competitive with ones where engineers armed with the same LLMs are building them.
> I recognize that crafting a 'perfect' prompt is impossible, but neither is writing the perfect code, or even the 'perfect' code style guide
This is not about "perfect code" or style guides. For code styles we have linters, that does not require any instructions. I'm talking about software architecture for large complex web applications that dozens of people (that also change frequently) contribute to and that is spread across many different repos/services and an environment with constantly changing business requirements.
The terms that are relevant here are: coupling, cohesion, vertical slices, module boundaries and so on. This is software architecture and coding agents are terrible at this and there is no prompt and no instruction fixes this that could reasonably fit into a context window. I don't even think that coding agents fail because the lack the instructions and therefore adding instructions won't fix these failure modes.
How would you know "the majority" from your anecdotes? Maybe you just spent your career working with incompetent people who didn't care.
And actually there's a point I forgot to address earlier, in my first comment:
>>>>> The thing is: people quickly discover that even mediocre LLM-code with a mediocre LLM-review, is still better quality than what they hand wrote and hand-reviewed.
People whose hand-written code is worse than "mediocre LLM-code with a mediocre LLM-review" are not going to discover the LLM-code is better, because they typically don't care. That's usually the whole problem with that kind of person.
> ...And now a lot of that code is actually better (big win).
> Basically: the code was so bad before, that un-reviewed LLM-code is now better than the average contribution. That means, that at least short term, the vibe coding can increase quality.
> The problem is that it also increases code volume (bad) and rapidly decreases understanding (even worse).
You're contradicting yourself here. Even accepting your statements uncritically, it doesn't sound like a "big win." It sounds like a marginal improvement that's ultimately self-defeating.
"Ninety percent of everything is crap"
The good part of LLMs is you don't have to worry about overloading them: you can just outline every problem with the code they produce.
The bad part of LLMs is they don't really "get better" at this stuff. I'm not training a human, and there's a limited amount LLMs can learn. So the training phase never really ends - it's Eternal September.
There's also the problem of this ultimately being my code. It isn't Claude's - Claude isn't a person.
I still read the code. I use LLMs to review it. But I also review it myself. Ultimately its faster than before, and probably better quality (because I can just give all the problems to the LLM), but slower than people doing zero review.
After I give feedback to the AI I then ask it if we learned something and then I ask it to store that guidance in a relevant skill file.
I have skill files for everything and anything in my project. Three just for testing - one for frontend, backend, and e2e. I have one just for frontend forms. I have one for project terms, which I ask it to read before doing anything, so it keeps the terms in the project right. I have one for doing db migrations and one for doing backend routes. I have many tens of skills that have been slowly built up like this.
Not my experience at all. Mediocre LLM-code, mediocrely reviewed is a loaded footgun aimed at both your feet.
Emphasis mine.
I can't phantom some that bad at coding. Using such exaggeration void your comment.
No, I find that most teams I've been on have 5% to 20% of their most artisan engineers actually giving a shit about the code, and gently coaching the other 95% to 80% of the engineers who are usually much more junior during code review to not push unmaintainable slop. If you're on a team that doesn't still have someone giving a shit, it's not a sign that there are no teams that don't give a shit, it's that you're on a shit team.
There are also teams where the incentive is to get to pull request (or merge request) as soon as possible, so that you can move the ticket across the board and relieve downward pressure. That usually means pushing subpar code to PR that you know you'll spend another few hours fixing. EDIT: I bring this up because this can bias one's belief that humans produce poor quality code, when you're usually looking at the first draft that was incentivized to be pushed out "too early".
Anyway, if you're on a shit team, but you're still satisfying product and nothing is blowing up yet, there's a pretty good sign that your software has no moat and will be the first to be replaced by LLM-generated software on-demand. This is probably where most niche B2B back-office, front-office software sits. Stuff that sits somewhere in the realm of "We could probably do this in Excel if we wanted to."
That is only true for bad coders, that in a prior era would have been known as script kiddies.
When you get paid to care, you will care. Unfortunately, no one cares, they just want results, any result. Bubble sort will do, especially for low volume tasks.
Use the time you save by not caring, to do other fun stuff.
That's not an option for people who "care". Like it or not, a lot of self is tied up in work. Feeling useless rots you from within.
What kind of time do you save, especially at work? At any normal software shop you have an endless list of things to do. And most often you don't get to choose the "fun" part.
The word professional im important here. I don't want to know, how unprofessional devs handle their craft.
Follow up work to generate markdown? It wrote a mess of manual string building instead of using said library lol. Even with strong AGENTS.md guidance around using existing and leading community libraries they will often take a hard left and write stdlib straight into your repo.
Y'all should scrap that feature and maybe the engineer. I believe the Shopify CEO recently referred to those types of PR as "slop grenades" that cause headaches for everyone else..
MORE MORE MORE like AI has given executives an excuse to ratchet up performance expectations by at least 3x (as in my company) up to 10x for certain start ups I've heard.
There's literally not enough time for a human to do all the activities around quality they were doing even a year ago.
Turns out, it was probably good that nobody spent time reviewing it.
Really the single biggest piece I use today is using a tool like superpowers to ensure your task is well defined. Added bonuses are its TDD implementation skills and multiple review steps baked into the workflow. Before I discovered superpowers I was manually telling claude to do these workflows, the plugin makes it easy.
In the repo itself:
* Keep agents.md focused; claude likes to really bloat it by default. The "Adding guidance for AI agents" rules go into every project and have worked pretty well.
* Aggressively use nested agents.md files. Focused rules located where they're relevant seem to do much better than having a large whole-project rule dump in the root agents.md.
* Recently I've started using the tech debt and deferred work documentation rules. Claude frequently decides on its own that some piece of functionality or issue is "deferred until later" or "out of scope". These rules help make it clear so that you can make it fix the item or at least have it documented for a followup session.
* Have it test all the things. Most of my personal projects with claude have about a 3:1 ratio of test:application code and high coverage. Claude make it easy to build test harnesses for things that most of us wouldn't have bothered with 5 years ago.
* Strict type checking, linting, static analysis, warnings as errors, etc. Anything you can turn on or add to block questionable code, do it.
* Use a claude pre-tool hook to run all of your checks before you allow a git commit command. Left on its own it can and will decide that it has a valid reason to bypass git commit hooks (husky) to commit broken code or tests.
I mean, sometimes work falls exactly at the tool's strongest suit/match.
I am trying to think of what a comparison here could be but, for example, I remember early days in my career where pretty much 80% of the work was writing boilerplate and using scaffolding/generator tools, plugging them in the various plumbing and pipes of the stack, and just ticking boxes through Jira
Lots of "CRUD" and/or similar "recipe" type of work that was really just turning your brain off and needed that grunt labour force
You may ask: why is the person even needed?
My answer is the same as before: I don't know, I didn't know why were they needed back them either, felt like all could be automated as well, maybe the cost to invest in automating and mapping that all out was never a priority and the ROI math was "good enough" for the business while leadership had other north stars they were worried about?
I've spent 1 month between august and early september writing some of the best code of my life. LLMs only provided feedback, I wrote all the code manually, still remember it by heart.
I was very delighted by the many architectural iterations that led to it. 9 files, around 10k lines of code (of those, 7k tests).
By the end of super funny exercise I kinda realized that if I had the same feature vibe coded it would've been better. I would've done much more and progressed more feature wise.
I just feel stupid hand writing my code.
It doesn't help that I work with stellar individual contributors. All of my team mates (except a junior) are either all former faang or contributed to projects we all use (from the TypeScript compiler to Linux). And they are all abandoning if not spearheading the abandonment of reading code. I'm talking people that truly loved the technical aspect of it and excelled in it.
I just feel stupid, like I'm carrying a weight that I should abandon.
Comments like yours feel would've made sense 6 months ago, but now are crumbling.
Software is essentially so cheap and throwaway nowadays that letting LLMs write it is imperative. When you find your use cases you start reviewing it or rewriting it thoroughly.
I’ve been using agents to do the code for me, but I explicitly tells it to iterate in small changes that I can review and approve as it happens, not after a 2k lines diff. It makes me understand what’s being made, and test every little change before we move on to change other parts of the code. Also helps you correct any misunderstanding right from the start.
And seen that JetBrains revenues still grew 6% YOY, it looks like after all there are still developers paying for an IDE.
I thought that by now, according to the AI kool-aid drinkers, there wouldn't be any developer anymore?
At this point of 2026, if you're reading code and still catching things, then the problem was before the code was written. You should have decided more high level preferences like invariants before the work began.
And this is a good thing.
Since the spring, I haven't actually needed to write the code, just look at it and make sure it's good.
All that I do from inside GitHub or GitLab.
I've had a JetBrains subscription forever and this is the first time I'm considering not renewing it.
So presumably your workflow is, agent tui -> push -> review -> find problems -> agent tui -> push?
Care to share any code or features that have come of your workflow? I'm skeptical of the quality and complexity this approach can handle.
Oh, boy, here we go... Sighs and pulls up a chair.
Using an IDE has nothing to do with looking at code. The best engineers I've ever known use what JetBrains aficionados would refer to as "editors", not full-blown IDEs. To a person, not one of them felt as though they were missing anything they wanted or needed. I would probably even say "Unix is my IDE". I have a terminal chock-full of advanced command line tools to search and manipulate codebases. It's always fun and convenient when a GUI gives easy access to those things, but it's just that: a convenience, and only when the GUI exposes the full option set of the underlying tool, which they almost never do. Basically, I can alt-tab to a terminal, press up-arrow to expose "cargo build", and hit enter to run it, about as easily as someone else can select the build menu in an IDE. Further, if that build menu option is any less configurable than Cargo.toml, I'd prefer the text config any day. And finally, "cargo build" works with any editor I'm using that day, even if they don't their own build system wrappers.
IDEs are fine for people who enjoy them. I grind my teeth whenever anyone hints that they're remotely necessary for, well, anything, or that people who aren't using them are somehow missing out on something. We know what we're missing, and frankly, we're not missing it.
Zed in particular, from the way it was described upon release, sounded like it should have been a JB competitor. Reality: It can't even move functions or structs!
At least, that was so in dynamic languages, like Python, and PHP, last I checked.
That's always been my experience. Not even close. One gives you legos that lets you make a plastic toy, and the other is an industrial machine shop for code.
I thought maybe I was holding VSCode wrong, though.
Likewise (Same with zed). I've given them a thorough try several times, assuming I was holding it wrong as you say based on conversations with others who use them effectively. I've reached the conclusion you say here each time.
I don't want to spend a lot of time finding, installing, and configuring the right combination of plugins to bring VS Code up to Webstorm level.
Also, I don't trust plugin/extension marketplaces anymore. There is lower exposure in having fewer dependencies.
I use Rider but need VS for some things.
But there's plenty of examples.
For languages like kotlin, java and even python JB is still way ahead of the competition.
vscodium[0] might require some aftermarket bells and whistles to reach feature parity with jetbrains' "swiss army kitchen sink" approach but at least vscodium is not data-mining me.
A year or two ago, I finally gave up:
1. The IDE was simply too slow - notably slower and "heavier" than VS Code in particular - and it seemed to regularly get slower.
2. Bugs - from the complex (TypeScript constructs that tsc itself handles just fine while WebStorm's code analysis kept throwing false positives on) to the trivial and silly (failing to properly handle the <col> tag in React), and often staying open for years.
Meanwhile, VS Code just kept getting better, addressing the complaints I had with it while staying fast.
I work almost exclusively in TypeScript these days; as other commenters pointed out, I'm sure that JetBrains products are still great for other languages.
And their refactoring tools remain second to none. I'm profoundly disappointed in our industry that the VS Code developers apparently looked at JetBrains, with its arsenal of expertly crafted, deterministic, testable refactorings, and said, "Nope, we'd rather make everyone use inherently random language models for anything more complex than Rename Symbol."
The remote dev story is bad, it won't play nice with Nix environments, and high DPI support on Linux kept breaking on every other update.
I still miss the Git client sometimes, but Jujutsu has filled the gap.
Microsoft's stuff is quite good, or you've got a really high bar.
> quite good
Good one.
Microsoft has had a very long reputation (for good reason) for having good developer tooling, even if Windows was not particularly developer friendly...
One such thing that Xcode has that IntelliJ doesn’t is per-pane history. In Xcode hitting back/forward navigates history for your focused editor pane whereas IntelliJ’s navigates history across all editor panes.
This might sound like a minor difference, but Xcode’s way gets me to where I want to go more quickly most of the time because I’m not having to wade through the likely-irrelevant history of the other panes. It’s a frequent frustration whenever I have to use an IntelliJ IDE.
Jumping through a stack of functions across classes and back seems like the most common case to me. I'm glad you like it but I would hate that.
The best thing to do would be to make it a checkbox, like IntelliJ does for almost everything else, but not that for some reason.
The redesign they've gone for also seems like a supremely weird choice. It's like they're trying to be more like VS Code, when their probably biggest selling point was that unlike VS Code, they offered a full and traditional IDE experience.
Their trajectory has been a deeply questionable mix of change for the sake of change and nervously doing what everyone else is doing.
Can anything serious/complex be done on mobile? I'm genuinely curious. It's seems bizzare in the context of IDE and tooling discussion.
That slow trickle of back and forth that gets our intelligent machines called "toasters" in a way not predicted by Battlestar Galactica at all, that really starts shining on mobile. Hands off on terms of signing off every little detail, hands on in terms of never being too far out of the loop, keeping the unattended steps small.
I'm usually working between VSCode and Codex/Claude Code at the same time, but find myself mostly in latter these days.
Anthropic is a different story, but I think it may still be possible via the Claude ACP agent (JetBrains' support of ACP is generally pretty good; I use it with anothe harness for open weight models regularly).
Any leverage that claude could benefit from LSPs or language/AST MCPs is undone by that tooling not being able to keep up or stay fresh, so the IDE just "runs hot" for no purpose.
Which means I'm incentivised to close my IDE while claude is working, and now I've got used to not looking at the code.
Like you, I really want a system that works better. I want claude to search and edit through better tooling, it would be faster, more accurate, and should in theory be able to leverage compilers to apply edits better and more accurately.
I don't want claude wasting an awful lot of time grepping for things that a compiler cache can answer, but if that compiler cache can't keep up then it's actively harmful.
I'm sure there must be a better way, there must be a way to have smarter more change-aware cache invalidation, and smarter more cache-aware claude tool use, but so far none has happened.
Long term I'm sure the pairing will emerge, but unfortunately I don't think that's going to come from the IDE vendor side, it'll have to come out of some harness research lab, where Anthropic or a competitor finds a way to reliably leverage this stuff for a speed and accuracy boost.
It's completely bonkers to me that an LLM can almost "natively" read profiler output, but doing so involves vast amounts of text and context ingestion, when there are real tools sitting there that it ignores in preference for either reading vast amounts or iffy python one-shot scripts to parse stuff.
With Codex GUI app and Astra you can communicate through screenshosts and collages. WAY faster and more precise for many types of jobs and workflows. Literally just scribble crap into the screens and it knows... no need to write out 50 paragraphs of prose to describe a button and its position.
I was using just command line too and Orca just leveled up everything around it. Still using the cli but inside of Orca. I
To each their own though, I’ve heard great things about Herdr setups.
Hi, we have such product already, you can try it here: https://plugins.jetbrains.com/plugin/33314-air
I heard rumors JetBrains started going downhill around 2022-2023 because they severed ties with employees in Russia's St. Petersburg, which housed their R&D and all (although many employees were relocated but who knows).
On Space case, I think they felt it became too complex to maintain internally while other great alternatives were very hard to compete against.
They were sad about it, as they really worked hard on these products, but it's also easy to understand why they make the decision. Despite the tools being nice, if nobody buy them, it's just a loss.
On a very related note, I'm probably very late to this discussion, but has anyone else noticed autocomplete in JetBrains products has gotten significantly worse after the advent of LLMs? It would previously take into account type signatures and all kinds of context, now it's clearly just a very minimal next token generator, often producing code that doesn't even compile.
- top-tier language intelligence
- all sorts of applications for building software, from IDEs to task trackers
- a huge, loyal user base
- being big enough to have deals with leading AI providers
They had the potential to lead the AI devtools race. Right now, good but quite basic tools like Pi, Conductor, or Herdr are getting good funding.
But JetBrains just failed to adapt. Their biggest AI attempt – Air – was way worse than Conductor, which is built by a team of few people.
I feel like there are just a few shortsighted people in leadership behind this flop. I will not be surprised if JetBrains will be defunct/shrinked in 5 years.
They are working on a cli agent; I tried it, but it silently injected hooks into all my other cli agents to re-target JB inference APIs, which caused me to burn through my JB tokens in like two minutes and b0rked all my running agent sessions.
They are working on a spec-driven thing, which I attempted to try but getting burned by the cli thing I abandoned it. It looks really interesting - it's a meta-harness, built and shipped with one of the Spec-Something frameworks, where you define your own specs for your projects, kinda like snake-eating-it-own-tail-of-specs. If spec-driven is The Future, they are at least trying.
There have been a few other things I can't recall, but my observation is that they are taking generative AI seriously as an existential threat, and probably (as another poster here put it) "heating the office burning tokens".
I doubt I will remain a subscriber for the entirety of next year.
Let's look at their AI product, it suuuuucks. They released it, and it literally did not function. I purchased it, and it kept giving me licensing errors. Contacted support and they couldn't tell me anything. Okay, cool, cancel it and refund me. This is useless.
That was a while ago. Today, it still sucks. AI Chat is a bolted-on afterthought that looks like a hackathon project and functions like one. Isn't deeply embedded in the editors. Clunky. Slow. Ugly to look at. Doesn't integrate nicely with all the tools. No native AI plugins, you're forced into their garbage.
What are they DOING?!?
I'm paying hundreds of dollars to use the IDE. The least they could do is integrate well with other harnesses (like every other text editor in the world does).
They really didn't do well with AI integration the past few years. When Cursor was all the rage, JetBrains was pushing their own service whose pricing wasn't transparent and just didn't hold up to SotA. I'd still agree that using Codex or Claude from CLI is a better user experience.
Yet, looks like their revenue is up. Wonder where they're investing.
Don't overestimate the relevance to this.
I think they've started to realise that and are trying to reign it in with 'Fleet' and 'Code With Me' deprecations.
They seem to be very bloated and unable to modernize their product lines.
One of the things we really use heavily is dynamic pipelines, as we have a lot of different stuff.
In teamcity, we had close to 1k build configs, and were able to replace this with about 20 dynamic pipelines in buildkite.
We did need to do a bunch of plumbing, but in this age of AI it means our developers don’t have to rely on devops anymore to get their stuff done to make all this work.
One of the problems was that our devs were “afraid” to alter teamcity build configs, as it all was more fragile than it should be and they were afraid to break stuff.
Teamcity allows for customization with plugins, but all that is so bloated with either Java or Kotlin and requires a shitton of domain specific knowledge to pull off.
Buildkite is much simpler with YAML and their plugin infrastructure which is effectively just hooks into scripts. It’s well designed.
Say what you may, VSCode feels lightweight in comparison despite a lot of plugins (I’m not a VSCode user but I do endure it at work).
Shedding IDE size, decoupling bundled plugins from shipped binaries, and improving file system sync would be great improvements they could do, besides pursuing AI and whatnot.
I don't get these comments. JetBrains AI assistant supports ClaudeCode, Codex and any ACP harness including OpenCode, in addition to their own. What is it with people saying they're stuck in the JB terminal etc. if they want Claude?
The quality of their software has been falling despite all recurring revenue. I used JetBrains for almost a decade because it just worked. JetBrains Toolbox is some of the worst software I've used, it causes more problems that it solves for me.
Needing to install a different IDE per language is also something I dislike about JetBrains, but not a deal breaker.
In my opinion sunsetting JetBrains Space was a major strategic mistake. It would have given them the moat they currently crave for to compete in the AI space, by enabling cool AI powered features (codex like sandboxes connected to their ides etc...).
All their AI products currently feel like desparate shots in the dark, while Jetbrains Space would have been a natural home, delivering strong value and differentiation.
Once Claude Code, Codex and OpenCode matured and discredited Junie, the next thing i looked for was a code review and CI/CD environment that was as seamlessly integrated to my IDE as possible. I was baffled to discover that JetBrains had just that but decided to sunset it in the midst of the AI war. Absolutely baffling....
It looks like software dev is going the way of natural language as the final spec that humans see. Regardless of whether this is a good idea or not, it’s happening. My boss asked us not to write any code manually starting in Jan, and now has hinted that we should stop reviewing code too.
Natural language as spec obviously has a ton of limitations. And here an opinionated IDE that can define this sort of workflow better is primed to gain a lot of market share, devs clearly aren’t fussed about switching between IDEs right now.
I should be able to, for example, click on a plantuml diagram and see what the endpoint definitions are, See where the request schemas are.
If I have Agents.md files scattered across my codebase I would like my IDE to help me manage them
I makes me sad. Jetbains used to be a company I looked up to because it always positively surprised me. Now I keep complaining.
I am not moving away from JetBrains anytime soon, but it does gets harder to justify when I spend considerable time in a competing offering that has better experience and is free...
As a long time C++ developer on Linux Clion was the best there was and it seems that they've completely neglected the core product. The core features are in a free fall while they keep adding new smart AI crap and shuffling the UI around and adding new show stopper bugs.
I also want to have the jetbrains code quality scans automatically ran and fixed, and maybe something that enforces permissions and a sandbox. Basically I want the IDE to be more of a control interface.
I don't think the problem is AI itself; they can have AI too, AI as capable as something like Cursor, for example. The issue is that their product is bloated and slow, and much of the technological leadership they once had has been overtaken by VSCode.
I disgree. Use their ide on a 16gb laptop and never had any performance issues. AI is the problem. Openai and anthropic are eating their lunch.
If engineers are abandoning IDEs then shouldn't they be following the engineers?
I have no idea what that contains, but it appears to be a rather large dip, compared to previous years. Overall it's not really that interesting without context and commentary from JetBrains.
For me, the things that made Jebteains great just don’t matter anymore.
I still use it a lot for reviewing the code.
GitHub or Tuicr for code review. Still waiting for an agentic first review environment- which Jetbrains has missed the ball on.
My guess is that people aren't abandoning their IDEs. Their market is probably growing. I suspect they're burning money on subsidized inference, just like everybody else.
Ironically, I finally got around to using AI to configure my Neovim setup with a decent F# and C# experience. I don't have it set up with a debugger yet, but at least I'm not paying hundreds of dollars every year for a company to neglect the thing I paid for.
They could have bought out Cursor early on too.
I uninstalled the plugin and it continues to open the AI Chat tab to helpfully suggest I install it
It's better to be the king of a niche.
'refactor' isn't just a blender. If I wanted agentic coding I would just do that. I'm quite happy for other people to so completely entangle themselves in agentic coding that they can't get out. Please proceed.
to add: I'm a paying JetBrains customer, but they could lose me if they vibecode themselves into a pile of slop. I'm not sure they're doing that, even if they're dabbling in it. I think there's still expertise there.
I have used their support before, to be extremely impressed. This is an area that they could differentiate themselves in.
Ironically, back then they praised JetBrains for not following hype staying focused on IDE and Dev environment
One sad thing is they gave up on Fleet and never unified all their IDEs. Reality is many people work in many languages and need to have good support for multiple langauges. The plugin model for other langauges in a primary langauge sorta works but it's not great compared to VSCode which can support many many languages.
Never looked into it further, but might be a factor...
https://blog.jetbrains.com/blog/2022/03/11/jetbrains-stateme...
https://blog.jetbrains.com/blog/2022/12/06/update-on-jetbrai...
Unlike others, like LG or Samsung, that put out a couple of press releases claiming they exited but in reality still do business including marketing or operating factories in russia. Or Apple that just switched all their business through neighboring countries and still continue to remove any app russian government demands and pays all the fines they get
Turns out I can easily get by on VS Code / Claude / ChatGPT / Antigravity. DataGrip is going to be hard to replace, but don't need anything more than the current version, hopefully they'll let me keep using it.
> Figures are the company's own (unconsolidated) statutory statements filed with the Czech business register…
Are these as reliable as the U.S. 10K or its European equivalent?
I assume that a company like JetBrains would be investing in shifting products around A.I., so it doesn’t seem too surprising that they don’t report a profit for 2025.
then Sbirka listin and download the filings. It's all in Czech so put it through GPT for translation
Summary:
JetBrains s.r.o. went negative because a large foreign-exchange loss overwhelmed a much smaller operating profit. The report explicitly identifies CZK 1.516 billion of currency losses caused by the Czech koruna strengthening against major foreign currencies. But “it was just accounting” would be incomplete: operating profit also fell 63.2%. These accounts use Czech accounting rules, not IFRS.
So two separate things happened: operations deteriorated by CZK 1.291 billion, and the financial result deteriorated by CZK 2.016 billion. Lower taxes cushioned the fall rather than causing it. Approximately 61% of the deterioration before tax came from the financial section and 39% from operations.
For cash generation, the reported operating cash flow is positive—but requires caution. It increased from CZK 5.059 billion to CZK 6.353 billion. However, the 2025 statement includes CZK 6.672 billion of positive net working-capital adjustments, while its before-working-capital subtotal is negative CZK 60.926 million. The positive final figure therefore should not be read as CZK 6.353 billion of recurring cash earnings.
Removing only that disclosed currency loss would produce CZK 1,191.121 million of profit before tax. That is a mechanical sensitivity calculation—not an IFRS profit figure or a fully currency-neutral result. It leaves derivative gains and all other reported amounts unchanged, and it should not be treated as adjusted after-tax profit. The report says the 2025 “other financial income” line consists mainly of derivative income.
Jet brains academy at the same time decided to make an anti AI vibe coding video about how people can't learn with AI.
I am so confused it feels directionless.
First, revenue is growing, assets - too. I believe company does some money burning to compete. According to the prev years nett income, they should have collected a reasonable amount of money so a little money burn doesn't harm.
Second, the Gross Profit is only 72.1m whereas the Revenue is 675m. That means, 600m is somewhere in the COGS. Not sure how to read this.
Which is a shame really - this is similar to old blacksmithing tools.
There are companies where you'd rather be the owner, and others where you'd rather be an employee, or a customer. I think the JetBrain's customers are the real winners in this one.
It's 16,000 * 1 million CZK, so ~730m USD, no?
I still use their IDE, but I would love to see a realy native view on Claude Code, that actually shows a preview of an image I pasted for instance, in a view that feels native to the IDE.
I’m not surprised.
Where are these financials coming from?
"Hey! Look! We grew to power by making perfect, powerful development IDE! Let's get a bunch DeZiGnErS on board to dumb it down and piss off everyone"
Yes, I HATE their new UIs (we are on the second take where we had NewUI and now it's Islands)... ClassicUI has almost 1m downloads because it makes the UI _sane_ and while I renewed my subscription for AllPack this year I've done it griting my teath... will see next year if I'll stick…
It was the first time I'd used an IDE, the first time I'd built a cross platform app, first time I'd used Kotlin, and the first time I'd tried AI coding.
The journey started with choosing KMP as the stack, then I figured "here's the company that released KMP, they have an IDE, they have AI, I'll use that".
It was really useful, and convinced me that AI coding was the future. I didn't know Kotlin (I still don't) and I don't look at any of the code. I do look at diffs sometimes (less and less). My main "review" is "reviewing test failures", which is a workflow I developed over the past year.
It was about 4 months into using it that I figured out that the IDE was really doing nothing.
I rewrote their worktree functionality as a couple of bash scripts. The build and test functionality was all gradle on the command line anyway. I was just using it as a chat interface and a markdown reader.
So I set up tmux and used Junie CLI (I liked Junie as an agent), Kimi Code and Pi Coding agent simultaneously on different projects. Junie CLI was pretty good, but it had too many instructions and when I started getting particular about my workflows, compliance was too difficult.
Kimi Code and Pi kept winning, eventually I stopped using Junie altogether. The name of the game was doing things in parallel and in the background. Editing the code had nothing to do with it.
The thing I missed was how JetBrains AI credits worked. I loved switching between models, and didn't want to tell everyone on the team to have their own accounts. I looked around and saw some LLM gateways and stuff like OpenRouter, but then they are all still charging extra, so I just wrote my own LLM gateway and connected it to Pi.
But then I was like "what is Pi really doing here?". I wanted a thing I could use from my phone, and using tmux over Termius is pretty weak, so I was like "Oh maybe I can have a mobile app that uses Pi as an API or something" but then I kept hearing the creator of Pi talk about how simple the coding loop was so I just wrote the coding loop into my LLM gateway and then created clients for it for iOS, android, macOS, windows and web, all using Kotlin Multiplatform.
Now I've got my dream coding agent: I create work trees at the touch of a button from my phone, I discuss with the agent using the "reply mode" interleaved reply feature, I have a flexible bash script based workflow engine, a centralised script/skill distribution framework, centralised billing/model gateway, all built into a single dev box that runs everything and can be deployed using one of those fancy curl -> bash pipeline things. I can deploy to dev, staging and production at the touch of a button from my phone. Dev and staging are IP gated behind CloudFlare tunnels, the production deployment goes straight to GCP, using a standardised framework.
My colleagues and I use it to ship real internal and external products and they're not even developers.
I haven't read any code or reviewed any "PRs". I don't even use GitHub or linear!! But man when I go for a walk and sit down on park benches and dictate to my coding agent in my phone, set the workflow running and then keep walking it feels like a super power!
And this was more or less 1 year from starting my first project using IntelliJ IDEA + Junie + OpenAI GPT 5 and winding up using a mix of models on my own platform that I share with my colleagues.
I don't understand how an IDE development company or, really, any "coding agent development" company can maintain a competitive edge in the face of that kind of pressure.
EDIT: I did find their Air product very intriguing but they didn't get it released quickly enough and it didn't solve the problem of having things running in the background easily enough. Also their worktree setup and teardown functionality was a bit of a drag. I built my own platform and started using it to build itself quicker than they got Air to the stage where I would want to use it. They STILL haven't released their mobile client.
This is why we see so many Electron apps these days (though Jetbrains was shipping IDE's before electron existed).
Well, that's the entire idea of those multi-platform frameworks: they take that off your hands.
The landscape is changing significantly, and I think these types of tools will become more popular.
Their main moat was smart refactor, and a few other nice tools to debug. regardless of what you think about coding is done, agents and your harness is the best tool. I heard they doing business accelerator to find a new business ideas. But as a company, hardly imagine anyone buying expensive IDE in 2 years. Why?
I guess you're all in on that Anthropic IPO with the "coding is solved" approach.
If the first part follows the second, the surprise is that revenue is up while the prevailing opinion appears to be "no-one needs to buy an IDE".
edit: added the extra words + I must mention I'm talking about legacy maintenance projects