Rahul Goma Phulore retweeted
Projectional Agent Toolkit has matured. It is no longer experimental.
MPS 2026.2 has been released! Expect substantial enhancements to the Projectional Agent Toolkit, Linux ARM64 support, numerous UI upgrades, and more. Give it a try: blog.jetbrains.com/mps/2026/…
Rahul Goma Phulore retweeted
i gave this repo to fable 5.2 (via my claude agent fig) and told him to have fun making something interesting...
def feels interesting to me (stay for the turn)
i am continually astounded at the creative choices these advanced models are making
卧槽,这踏马太毒了
DeepMind 掌门人、诺奖得主 Demis Hassabis 刚刚把延续了上百年的现代学校教育底裤彻底扒光了:
全球几十万名数学老师每天关在办公室里,为同一门中学数学课重复手搓着一模一样的 PPT,这简直是人类智力资源最荒诞的工业级空转。
很多人至今还把名校名师的课堂讲授当成稀缺资源,拼了命去抢学区房和重点班,
但 Hassabis 直接用最冷酷的第一性原理砸碎了这个幻觉,
标准化的知识灌输从来不配占用昂贵的线下课堂,死记硬背和刷题完全应该被踢出教室,交给能按每个孩子毫秒级反应速度实时调频的私人 AI,加上全世界最顶尖的那几个大师录好底层大课,就足以把全球基础教育的讲授环节一次性彻底平替。
过去两百年里,学校本质上是一座把千差万别的碳基大脑强行塞进同一条流水线、按同一个节拍器拧螺丝的工业时代兵营,
老师沦为了人肉复读机,学生被困在枯燥的题海里比拼谁更像一台劣质硬盘,
而一旦 AI 和顶级大师把标准化的知识传递彻底接管,线下教室唯一剩下的合法存在价值,就只剩下了机器永远无法通过权重计算出来的五个维度:
人际博弈、复杂项目实战、创业野心、创造力,以及最致命的判断力。
这里有一个极度冷酷的反直觉真相:
当个性化 AI 把考高分的边际成本砸穿地板,按标准答案培养出来的做题家,在出校门的那一刻就已经直接沦为了算力废料。
未来的阶层分化,从来不再取决于谁的脑子里背下了更多现成的公式,
而是取决于当 AI 把一万种完美方案同时拍在桌上时,谁拥有拍板做决定的判断力,谁能攒起一个活人团队去把事情干成,
所以别再逼着孩子在死记硬背的泥潭里跟硅基芯片比拼记忆容量了,当流水线式的教书匠和做题家同时迎来历史性失业,谁能先把教室变成训练人性直觉与创业野心的实战沙盘,谁才能在算力时代拿到唯一不被平替的入场券
i went to bed and asked claude to paint an autumn tree overnight.
at around 4am, it realised that it didn't have some shades -- so it stopped and titrated its own paint: diluting red, sienna and madder step by step on a second palette, then measuring each pocket from a photo.
woke up to this beautiful watercolor painting. 303 brush marks, took about 4.5 hours 🍂 (still working on the speed)
Rahul Goma Phulore retweeted
Generative UI for conversational agents.
Combining @aisdk with Chat SDK and 𝚓𝚜𝚘𝚗-𝚛𝚎𝚗𝚍𝚎𝚛, you can go straight from LLM to UI on platforms like Slack and Teams.
I believe this will become the dominant Human-Agent Interaction (HAI) paradigm:
vercel.com/changelog/json-re…
Rahul Goma Phulore retweeted
we've completely rebuilt how AI agents work inside JetBrains IDEs
it's called Air, and starting with 2026.3 it ships with all our IDEs
Some features:
⛽︎ sign in with your existing ChatGPT, GitHub Copilot or Google account. Claude subscriptions work in terminal view
⛽︎ or bring your own OpenRouter, OpenAI, Anthropic or Gemini API key for supported chat agents
⛽︎ agents work right next to your code, so you can jump into any file they touch without leaving the IDE
⛽︎ hit a limit mid-task? switch to another subscription or API key right in the session, the work keeps going
⛽︎ Claude Agent, Codex, Junie and Copilot work out of the box. add Gemini CLI, Antigravity, OpenCode, Pi and more from the ACP registry, or connect your own agent through ACP
⛽︎ run agents in parallel in separate Git worktrees, then cherry-pick their changes back
⛽︎ agents get the IDE's symbol search, rename refactoring, inspections and run configurations, plus the debugger in IntelliJ IDEA and CLion
⛽︎ Junie Lite is free with a JetBrains account
⛽︎ leave notes on code or diffs and send them to your agent, Claude Code and Codex terminal sessions included
⛽︎ set up MCP servers once for every new agent chat, add skills from folders or GitHub
⛽︎ see at a glance which agents are running and which are waiting for you, use Caps Lock is LED of agents status
⛽︎ review the last turn, roll back individual files
⛽︎ stuck in a merge conflict? hand it to an agent right from the merge dialog
⛽︎ save agent presets and pin the prompts you keep reusing
⛽︎ macOS, Windows, Linux. Remote Development over SSH, WSL and dev containers too
and yes, you can change the chat text size
and much more features are coming before NY
Rahul Goma Phulore retweeted
Might be controversial, but:
I have found regressions to be far less of a problem with agents than with humans.
DeepSeek continues to be a dark horse. Glad to see at least one harness investing in extensibility beyond TUIs. (And no, TUIs aren't CLIs, however much we'd like to pretend otherwise.)
youtube.com/watch?v=VKmUC5uk…
2
175
Rahul Goma Phulore retweeted
Drag-and-drop makes the digital graspable, but building it well is fiddly enough that many don’t bother. Declarative Dragging (with Josh Horowitz & Jeff Heer, #uist2026 best paper award), lets you make an element draggable just by listing the states dragging it can reach.
maybe a hot take but i now consider adversarial reviews mostly a waste of tokens. far better to use those tokens on empirical combined with formal verification. i have updated pstack to use the interrogate skill less, and eventually i think i may remove it altogether
i have found very little value with code review in the abstract, agents tend to just get lost in the nitpicks and yagnis
Rahul Goma Phulore retweeted
I did not know this existed till recently. Goldmine for nerds.
github.com/trimstray/the-boo…
Rahul Goma Phulore retweeted
AI may well be able to write massive software projects “from scratch”, but that almost certainly isn’t the fastest / highest performance / highest security / most token efficient way to do things. Good building blocks matter.
In addition to RL’ing the agents on final task loss, we should try to get them to regularize the building blocks as well. What would the standard library look like that makes the agents most effective?
It is likely at the limit that it turns out to be some alien organization of code, but given the existing human-bias in training, I bet that in the near term it would be lovely code that old programmers would appreciate.
I suspect the same could be said for mathematics, but that is out of my lane.
augmenting human intellect
when i started making software, i wasn’t dreaming of a factory.
i loved that something on a screen could become an extension of my mind. a place to put a thought before i understood it. to move things around until new connections appeared. to make little systems that worked the way i worked, even if it made no sense to anyone else.
the computer wasn’t interesting because it could do work without me. it was interesting because of what i could do with it.
the early lineage of computing was built around this possibility. in 1962, Engelbart described augmenting human intellect as helping a person understand complex situations and find solutions that were previously out of reach. his starting point was the human being, not the autonomous machine.
he wasn’t describing a faster black box. he was looking at the whole relationship between a person, their tools, their language, their methods, and what they could learn to do with them. the capability belonged to that whole system.
somewhere along the way, we started telling a much smaller story about a much more powerful technology.
more automation. more agents. more software producing more software. more output from fewer people. more growth. more numbers to prove that something is happening.
and less attention to the person any of this is supposed to be for.
i don’t want to pretend computing had a pure innocent beginning. replacing human labor was one of its ambitions. even in 1960, Licklider distinguished human-computer symbiosis from systems where the remaining people mainly served the machine. he wanted computers to participate in the formation of ideas, not only execute problems already defined.
that distinction feels important – does the system help you discover what you mean? or does it only want you to submit a request, and wait outside while it works?
sometimes waiting is exactly what i want. please do the search. move the files. take away the repetitive work.
but not everything difficult is overhead.
sometimes moving the pieces around is how you understand them. sometimes making the thing changes what you wanted to make. sometimes you need to see the wrong version, touch it, take it apart, and discover a better question.
i want tools that leave room for that relationship.
in his 1981 paper on Smalltalk, Ingalls described a system meant to support everyone’s creative spirit. personal mastery mattered: an individual should be able to comprehend the system, rather than remain dependent on something permanently beyond their reach.
he also argued that computer models should fit the human mind, rather than demand the reverse.
not one perfect workflow for everyone. systems that different people can inhabit differently. someone who thinks through pictures. someone who needs to write. someone who understands a problem by building a simulation. someone whose way of organizing their life doesn’t resemble a SaaS dashboard.
a system you can reshape as your understanding changes.
this is what i want AI to make possible. not just pumping out software, but having a living relationship with it. being able to ask why something works this way. change one part without surrendering the rest. see what happened. undo it. learn enough to make the next change yourself.
the machine can become more capable without making the person smaller.
but that won’t happen just because we make the models better. we have to care about it. design for it. notice when we are making someone more dependent while calling it empowerment.
i don’t want to measure the future only by how much work happens without us.
i want to know what becomes possible for the person who couldn’t participate before.
what can they understand now? what can they express? what can they change without asking permission?
when i say augmenting human intellect, that is what i mean.
not a world that no longer needs us.
a world we have more ability to shape.
Rahul Goma Phulore retweeted
Next question: why are you still using branches?
We talked about PRs. I don't think they make sense anymore, if you rethink them from first principles.
Yes, if you only use them to trigger CI, then sure, go ahead. That's a fat commit, not a PR. But for mandatory code review? Knowledge sharing? C'mon.
But some of you said: "we use PRs because we use branches! I love to keep my stuff on branches."
And I'm here to tell you: you don't need branches! You can just push to main.
It's called trunk-based development and the idea behind it is true continuous integration: you continuously integrate your changes with the trunk, the main branch.
It's been around for a while, it works. Just yesterday I talked with someone who said they've used it in an org with 400 engineers, without any issues. Ruby, the project, uses trunk-based development.
The main idea is that you want to avoid long-lived branches. They're bad, because branches can diverge and merging can turn into a thing. And you don't want routine operations to become a thing.
Even when I worked in teams that used PRs and branches, I considered it a smell when a branch lived for longer than a day or two.
But when I shared this with others, I'd often get something back like this:
"Well, good for you, but no. MY thing, what I'm working on, that can't be done on main. It needs to be on a branch! It has a database migration, it changes the underlying shape, the architecture, it refactors this and changes that. It can't go on main yet! I need to merge it all at the end."
And then I'd say:
"Nah, I can merge nearly anything continuously in small commits to main. You split things up. Add the column first, merge that, deploy it, now it's out, works, safe.
Add the helpers first, merge them, get them out.
Want to migrate from legacy pattern A to new pattern B? Don't do it all at once. Add the dependency, then migrate A to B, one by one, safe."
If it can be merged in a large change, I bet it can be done in small increments that you merge to main.
Yes, there are exceptions, but it's 0.5% of cases, not 50%.
But there was a real problem with this approach: it was hard!
There's a lot of "meta programming" you have to do: make sure this small first change compiles and runs and the tests work, merge it, get it out, monitor it; then do the next small piece, make sure that works and get it out; then maybe push some still-unused dead code, add a feature flag, add a config variable; or keep both configurations working at the same time, etc.
That meant sometimes it was just easier to do it in a big fat branch. But big fat branches are risky!
A system that continuously flows is safer than a system that starts and stops in spurts.
But -- you guessed it -- here's the good news:
Now, with agents, all of these chores are no chores at all!
Agents are great at adding feature flags, they're great at splitting up code, they're great at keeping track of three changes and merging them one by one and watching them roll out. They're great at keeping two configurations working for a day. They're great at migrating one by one.
In other words: it's now 10x easier to just work on main and make sure everything is continuously integrated and working.
It's now easy to make sure the system constantly flows.
And look, ...
I'm not here to convince you to switch to trunk-based development. Just a ruse to get you to read this. (But also, hey: try it! Pushing to main is amazing.)
I'm here to make you RETHINK how you develop software.
Don't just use agents to replace your typing.
Use agents as the magic code-writing machines they are. Everything that was hard about software development because it involved writing code -- even the meta programming -- has become easier.
You can now reach for the stars! But you need to look up.
Rahul Goma Phulore retweeted
If a model has written the entire skill without any input from you, you don't need the skill.
question from the TL:
> quick question, do you think consuming more skills in the same session unnecessarily dirties the context?
>
> Say you have a 5 step work, each step with a skill. You can either run all on single session, divide into subagents with relevant skills, or compact or new chat per step.
my intuition says 5 steps in a process is fine. Each successive skill will take a share of attention from previous skills,
so if you have a VERY long complex process where you need skills to STACK (ie instructions from skill 2 must still be honored while skill 6 is executing)
Or if you have many (eg 200) separate skills that all need to be active during a session ( think: agent memory snippets implemented as skills, probably an antipattern in today’s harnesses)
Then you want fresh context, subagents, or to synthetically precombine many skill contents into a single user message (although then you lose the attention recency bias for instructions in step 6 of the process)
Also worth noting that good skills can be a mix of:
- information not in the weights
- steps to execute a process (not in the weights)
-general steering or behavior
They usually contain all three, but what’s in your skills nudges the meta here.
More instructions / process steps? You wanna string those out
Mostly information? Probably safe to combine into one user message.
Behavior? Depends. Adherence can decay over a long session. Fine to split or combine, but if it’s important, you want some way of repeating important rules, either by including rules in all the steps of a process, or by something more deterministic like hooks
And OF COURSE I’m begging you PLEASE stop putting stuff that’s in the weights in your skills. You are wasting time and locking in a specific, potentially suboptimal behavior.























