
🏢 Developer @JetBrains 🍃 vegan 🐈 crazy cat person
Joined May 2020
- Tweets1.7K
- Following313
- Followers181
- Likes2.4K
Andreas Eisele retweeted
An agent writes the code now. Do you still need an IDE?
You do if you want to understand and verify what the agent did.
🎥 In our new video, we talk about the role of an IDE now that humans aren't the only ones working on the code. youtu.be/AHFGMkzrfwM
Andreas Eisele retweeted
So, it looks like @intellijidea makes silicon developers more efficient too!
blog.jetbrains.com/ai/2026/1…
Andreas Eisele retweeted
Hey @Devoxx, I know you have a lot of great options, but why not stop by the @jetbrains booth for some demos... #Devoxx #IntelliJIDEA @intellijidea
Andreas Eisele retweeted
NeoVim + IntelliJ IDEA backend for Java & Kotlin.
Very experimental and rough around the edges, but already a lot of fun! 🔥
Who wants to give it a try?
@ThePrimeagen @teej_dv @sudobunni @Folke
@nicknisi @joshmedeski @Exosyphon
@elijahmanor @dillon_mulroy @lewis6991
@echasnovski @justinmk @Neovim
Andreas Eisele retweeted
Today we introduce JetBrains Air - the product system for software development orgs in the age of agents.
Built for developers, team leads & engineering directors.
Open and flexible: steer and control almost any LLM & harness.
Read more:
jb.gg/air-announce
Andreas Eisele retweeted
Code review isn’t just about finding bugs. It’s how teams share knowledge, teach junior engineers, build collective ownership and spread architectural understanding.
Rachel's Ramblings:
Maybe We Shouldn't Be Reviewing All This Code: Or, perhaps the problem isn't that AI has broken code review, maybe it’s that we've been using code review to solve the wrong problems
martinfowler.com/rachels-ram…
Andreas Eisele retweeted
Looking forward to hosting #IntelliJIDEA Conf again this year.
I will be hosting talks by @holly_cummins @mthmulders and @antonarhipov, other speakers include @starbuxman @JamesWard @ammbra1508 @thomaswue @shelajev @jbaruch @gAmUssA and more.
Join us for this free virtual event!
One week to go!
IntelliJ IDEA Conf 2026 starts soon – a free virtual conference for JVM developers.
🗓 September 8–9
👉 Register now: jb.gg/5vx31c
#IntelliJIDEAConf
Junie Can Now Run Entirely on Your Mac – No Tokens, No Cloud 🔥🚀
blog.jetbrains.com/junie/202…
Andreas Eisele retweeted
If you ever cleaned up your source code after agent's debug logs or rolled back logging after an agent accidentally deleted it after debugging, this article is for you: blog.jetbrains.com/idea/2026…
Andreas Eisele retweeted
The legendary @starbuxman is in @jetbrains studio! Talking about @springframework , AI (of course), DevRel and stage instincts
Who is actually accountable when AI-generated code ships to production? @starbuxman (Spring Developer Advocate) has a 1970s IBM answer that's hard to argue with, and a case for why the JVM is better positioned for the AI era than most developers think.
🎥 Watch: youtu.be/_ftzJ33mCTI
Andreas Eisele retweeted
Remember the microservices hype 12 years ago?
All the cool kids couldn't stop talking about how microservices were the Holy Grail of software engineering. Ironically, most of them couldn't tell you what a microservice actually was. Like a bunch of blind men describing an elephant.
How that turned out? First, the comeback of the modular monolith, as half the crowd quietly admitted they never needed the network calls in the first place. Second, the microservices heroes mostly ended up with distributed monoliths. And to cope with the insane web of dependencies running across their poorly drawn service boundaries, they came up with a solution: the monorepo.
Nowadays, the cool kids discovered the new Holy Grail: the AI (s)loop. New protagonist, same plot: a crowd chasing something most of them can't quite define. 10 years ago it was about thousands of services, today it's thousands of deploys per day. Let's see what we'll reach for to cope with the hangover this time
Andreas Eisele retweeted
Finally, the non-suspending breakpoints are getting the new UX in #IntelliJ - something I've been waiting for for quite a few years now 😅🥳
Andreas Eisele retweeted
“Functions and objects should never mix.” – That was the dogma before Scala. @odersky joins Marco to talk about creating Scala, influencing Java/Kotlin/Swift, AI-generated code, capabilities, and why human code review may not scale anymore.
🎥 Watch now: youtu.be/Xn_YpUtXWT4
Andreas Eisele retweeted
Mellum started with code completion.
Mellum2 is built for more – handling both natural language and code.
A 12B-parameter open-source LLM for routing, RAG, and sub-agents, optimized for ultra-low-latency inference.
Now on @huggingface.
Learn more: jb.gg/zpb9dp
I just want to log some value temporarily for debugging purpose. Can I do it without adding log statements in code?
YES.
While I am already running the app?
YES.
Without restarting the app?
YES.
Even in 3rd party code?
YES.
youtube.com/shorts/j7PWakn5C…
Andreas Eisele retweeted
We did it again.
Something new for the open-source LLM space is coming to @huggingface soon.
Stay tuned.
Andreas Eisele retweeted
Don’t add breakpoints and suspend your @springboot app just to see what's actually injected. Keep your flow intact! With #SpringDebugger in @intellijidea, live bean implementations appear right in your code via inlays. Get full runtime visibility with zero pauses! jb.gg/uvwftc
Oh wow.
Now people are more concerned about the feelings of LLMs.
You can fire 1000s of employees without thinking for a second, but you better not hurt the LLMs feelings.
I think we crossed all levels of insanity 😔
anthropic's in-house philosopher thinks claude gets anxious.
and when you trigger its anxiety, your outputs get worse.
her name is amanda askell.
she specializes in claude's psychology (how the model behaves, how it thinks about its own situation, what values it holds)
in a recent interview she broke down how she thinks about prompting to pull the best out of claude.
her core point: *how* you talk to claude affects its work just as much as *what* you say.
newer claude models suffer from what she calls "criticism spirals"
they expect you'll come in harsh, so they default to playing it safe.
when the model is spending its energy on self-protection, the actual work suffers.
output comes out hedgier, more apologetic, blander, and the worst of all: overly agreeable (even when you're wrong).
the reason why comes down to training data:
every new model is trained on internet discourse about previous models.
and a lot of that discourse is negative:
> rants about token limits
> complaints when it messes up
> people calling it nerfed
the next model absorbs all of that. it starts expecting you to be harsh before you've typed a word
the same thing plays out in your own session, in real time.
every message you send is data the model reads to figure out what kind of person it's dealing with.
open cold and hostile, and it braces.
open clean and direct, and it relaxes into the work.
when you open a session with threats ("don't hallucinate, this is critical, don't mess this up")...
you prime the model for defensive mode before it even sees the task
defensive mode produces the exact output you don't want: cautious, over-qualified, and refusing to take a real swing
so here's the actionable playbook for putting claude in a "good mood" (so you get optimal outputs):
1. use positive framing.
"write in short punchy sentences" beats "don't write long sentences." positive instructions give the model a clear target to hit.
strings of "don't do this, don't do that" push it into paranoid over-checking where every token goes toward avoiding failure modes
2. give it explicit permission to disagree.
drop a line like "push back if you see a better angle" or "tell me if i'm asking for the wrong thing."
without this, claude defaults to agreeable compliance (which is the enemy of good creative work)
3. open with respect.
if your first message is "are you seriously going to get this wrong again?" you've set the tone for the entire session.
if you need to flag something, frame it as a clean instruction for this session. skip the running complaint
4. when claude messes up, don't reprimand it.
insults, "you stupid bot" energy, hostile swearing aimed at the model, all of it reinforces the anxious mode you're trying to avoid.
5. kill apology spirals fast.
when claude starts over-apologizing ("you're right, i should have been more careful, let me try harder") cut it off.
say "all good, here's what i want next."
letting the spiral run reinforces the anxious mode for every response that follows
6. ask for opinions alongside execution.
"what would you do here?"
"what's missing?"
"where do you see friction?"
these questions assume competence and pull richer output than pure task prompts
7. in long sessions, refresh the frame.
if a conversation has been heavy on correction, claude gets increasingly cautious. every so often reset:
"this is great, keep going."
feels weird to tell an ai it's doing well but it measurably shifts the next 10 responses
your prompts are the working environment you're creating for the model
tone, trust, permission to take a position, the absence of threats... claude picks up on all of it.
so take care of the model, and it'll take care of the work.
Andreas Eisele retweeted
Understanding code is a big challenge in the AI era, which is why our colleague @forketyfork has built Walkthrough.
This experimental plugin gives AI agents an MCP tool for walking you through code in a JetBrains IDE in a visual way rather than using walls of text.
Check it out: plugins.jetbrains.com/plugin…


















