Václav Pech

Yes. Or use an local qwen-level model instead of LUNA, if available.

JetBrains Junie is one of the most cost-efficient coding agents on the market today. Internally, we see Junie power users consuming 2–4× fewer tokens than with Codex or Claude Code—while achieving comparable productivity. Here are a few simple tips to get the most out of it 🧵

Prompt agent like caveman? Our evaluation shows that in real tasks, this technique does not compromise quality, but only manages to reduce token use by about 8.5% – much less than advertised. Detailed analysis here: blog.jetbrains.com/ai/2026/07/spe…

A huge amount of the Anti-AI code sentiment massively overestimates the quality of human code outside of a very small set of open source and high quality company codebases. Human Slop is everywhere and can trivially be improved on by any opus level model.

Free local-LLM tokens change how I use agents: I restart struggling sessions instead of rescuing them, keep runs short, delegate even mundane Git/issue work, and experiment more freely.

Yeah exactly. I've reviewed a lot of human code in my career. Every company I have worked at over the last 20 years has been an "every change needs to be reviewed before merge" type of shop. And in the process I've caught an enormous number of bugs and logic errors. Almost everything I review has problems. Reviewing AI code honestly doesn't feel much different to me than human code ever did. Most of the problems I catch feel just like problems I've seen in human code. I feel like the people complaining about AI code quality must never have been in a role where they are regularly reviewing their colleagues' code?

I spend a lot more time in the IntelliJ diff view than I do in my AI agent. For projects that matter, that is how it should be.

DSLs by/for Agents

The smartest models don’t necessarily guarantee the best results. Vladislav Tankov, our CTO, explains how with JetBrains AI for Teams and Organizations, you can maintain quality and manage costs with smaller models through context management, code verification, and reinforcement learning. Discover additional insights: jb.gg/b0i7hq

I'm positively surprised how the Junie agent with a locally hosted Qwen 27b model can handle modelling tasks in @jetbrains_mps . Granted, I tend to be more forgiving seeing a $0 price tag attached to my sessions :)

Agile Law Execution Factory (ALEF) developed by the Dutch Tax Administration with @jetbrains_mps is now open-source - github.com/belastingdiens…

Coming very soon in MPS 2026.1 - coding agents working with the MPS Console.

I’m opening my workshop “Concurrent Programming Fundamentals for the AI Era” to external teams for the first time. Concurrency isn’t really about algorithms or APIs. It’s about being able to look at code and see what can happen between threads or coroutines, and how to prevent possible races and bad interleavings. This intuition is the hardest thing to teach. Over the past 8+ years, I’ve taught concurrency at universities and later turned that experience into internal workshops at JetBrains. I ran the workshop several times for 250+ colleagues and received overwhelmingly positive feedback, with many participants saying it changed the way they reason about concurrent code. In the AI era, this skill matters even more. AI can generate code quickly and confidently, but subtle concurrency bugs still need human understanding, careful testing, and debugging intuition. It’s a 4-day, hands-on workshop for JVM developers. Participants implement classic and modern concurrent data structures, dissect tricky bugs, and learn practical testing and debugging techniques in Java or Kotlin. I’m now looking for the first external teams who’d like to try it. If your team works with backend systems, infrastructure, databases, developer tools, coroutines, virtual threads, or other concurrency-heavy software, I’d be happy to talk. 👉 Details: nikitakoval.org/workshop

1. as a mental model it is more correct to think of fable+ class models as english -> code interpreters - converts your idea into code into "correct" code regardless of problem complexity and output complexity (diff size). Fable 5 will be the worst of this new class of models 2. diff size/complexity is to be managed purely for review: small diffs - in high risk areas of code (auth/identity/data access/network access/money movement) large diffs for code that can be empirically verified (frontend/backend plumbing/code without network or db access/performance code that can be empirically verified) 3. time it takes to ship software is completely disconnected from time to produce the PR - how long the work takes depends fully on ability to review/merge code while managing risk at scale 4. solving the bottlenecks for above matter enormously- linters/testing/CI/shadow mode verification/empirical verification 5. agency matters enormously- what are the biggest bottlenecks to speeding up the loop and eliminating them? what are the problems that need solving and when do they need solving? what does it take to the solution to all of them today? 6. deep understanding of the full stack matters enormously- what problems are worth pursuing? is there a higher level of problem abstraction to address first? should I give it the sub-sub task, the sub task, or the task itself. what are the major risks with this PR (order of importance: security holes/correctness holes/performance holes). is there a higher speed way of producing data that allows me to merge this? should this be run in shadow or in a sandbox or a flag. understanding every line of logic may not be needed but understanding and managing risk matters enormously. 7. the cost of complexity itself is changing. it might be now worth "maintaining" 50% more code to get a 5% performance win. getting the right abstractions matter less because larger refactors are less tedious. code quality nits become huge drag. very likely, a much smarter model will be maintaining your code so worth taking on more technical debt now. taking the time to hand architect and rebuild systems comes with an enormous cost of velocity 8. if it quacks like a duck and walks like a duck, it's a duck. For low risk cases, it might be more sane to treat code chunks (services / functions) as a black box, like we do for neural networks: do full empirical verification only: has code produced correct outputs for the last 10,100,1000,10k inputs ? can we quarantine this large piece of code - no outbound access to network / database ? what happens when this code is wrong? do we get hacked/or crash(memory/cpu)/is an inconvenience? is it internal facing or external? what can we do to address these risks? 9. eventually, logical verification (line by line review) will come at an enormous cost- save it for where it matters and build systems that are tolerant to empirical verification. is there a decorator that prevents db / network access? correctness bugs are significantly easier to rectify than access bugs 10. what are the rails that allow for even faster iteration? code permissions can be opt in - db writes, db reads, network egress (to where?), PII access. how long does it take to get shadow mode data? how many PRs can be tested? What are the categories of diffs

We talk a lot about how important it is to set up self-verification loops. Especially in the age of powerful models that can run for long periods of time, self-verification is a key ingredient that enables the model to run for much longer, delivering a result that is closer to what you intended, so you can do more without having to constantly check in on Claude as it works. @delba_oliveira gives a great breakdown of what that looks like and why it matters

From a picture of your idea to a @jetbrains_mps language definition: 1. Draw your idea on a white-board 2. An agent equipped with the new MPS mcp tools takes care of concepts, editors, constraints, generator, ...

From an idea to a @jetbrains_mps model (MPS 2026.1): 1. draw a picture 2. ask any coding agent 3. review the created model in MPS

Agents manipulating workflow definitions:

Teaching coding agents how to manipulate @jetbrains_mps models. Thorough and persistent students:

Absolutely! E.g. the `get_file_problems` mcp tool that feeds agents with @intellijidea static code analysis results is a treat.