Pinned Tweet
About two years ago (GPT-4o era just begun), I came to the realisation that we’re very close to superintelligence, but I had a few concerns.
The first one was: why would you cram words but not use images, video, sound, and so on for training? Another concern was: why don’t you let the model interact with the physical world to train itself? The physical world has an effectively infinite amount of data, and it’s pretty easy to tell whether you succeeded or failed. Recent research suggests that most specialised scientific models converge on the same patterns – basically, representations of physical reality. (Think Tesla’s FSD merged with Grok, evolving in Optimus’ body. But a cockroach-sized robot could be a massive learning platform too. It’s also much safer than human-sized robots, and it’s easier to build an information-rich sandbox for.)
Another realisation is that we’re forcing the intuitive mind to do logic, which, as humans, we know is really hard (see: logical fallacies, and the overall state of human rationality). It’s obvious the two modes should be separated. Whenever precise thinking is required, the model should use the appropriate tools – or build the required tools as needed. And it shouldn’t be only Python or JavaScript: it should be able to use all kinds of systems, like Prolog, provers, simulators, and so on. The feedback loop between the two modes is the key.
And the last realisation I had is that we’re completely wrong about context. Humans’ working memory is laughable compared to an LLM’s context window, but for some reason we decided it’s still not enough. While the previous points are becoming mainstream (to some extent), this last point has only been touched on recently, as far as I can see.
My guess is that current LLMs can outperform humans by a big margin in most text-based tasks if we figure out a good way to work with their context.
One of my ideas here is unlimited recursion: allow the model to split the job into tiny pieces and delegate them to other instances of itself. The next instance takes another look and splits again, and this continues until the system reaches an atomic task that can’t be broken down further. My assumption is these leaf tasks will end up primitive and trivial for any SOTA model.
The harness managing the whole thing should be something like a deterministic state machine that manages the execution stack and the memory. Since the decisions are made by the model, the harness itself can be quite primitive – something like a cellular automata environment. The reasoning complexity would emerge from very simple rules (though it would obviously take non-trivial effort to nail the rules down to prevent drift and infinite branching).
One more idea: context should be managed as a personal knowledge management system, like Roam Research or Tana – infinitely nested nodes with direct and backlinks, and the ability to reference any node in multiple places (like a hardlink in a file system). (A file system with Markdown files might work as a medium.)
The model would manage its context by creating an outline where higher-level nodes summarise lower-level nodes, and it would deliberately fold and unfold parts of the tree to focus on what’s relevant for the current task. Basically, this graph would act as both short-term and long-term memory. This feels much closer to how the human brain works with attention.
Just nesting might not be enough at some point, so the ultimate solution would be a graph you can start from any node, with tools to query it. The model would create specialised views it needs in the moment. And as long as it has instructions on how to use this graph, it should be able to recover from any state.
It would be fun if people could contribute to such projects by directly donating tokens for the features they need most at the time.
Todos los productos de Adobe reimplementados desde cero, gratuitos y de código abierto
→ getartcraft.com/apps
I'd love it if ChatGPT desktop and Claude Code were as malleable as Obsidian or VSCode.
Valery Sibikovsky retweeted
tired: dog ate my homework
wired: cloudflare was down
inspired: three consecutive ai civilizations rose and fell inside my macbook during a forced restart. My notes app and chrome tabs did not survive the third regime
By banning artists’ names, Suno makes all the music sound like clones. And if you cannot record/produce good enough audio to use as a style reference, then you are out of luck.
Martin Mull once said that writing about music is like dancing about architecture. And this is what we’re literally doing in Suno these days. We can prompt the model with a few words that inevitably drive it toward a small number of generic solutions, but any non-trivial artist can never be reduced to a particular genre or a subset of genres. Their styles are always high-dimensional and cannot be usefully reduced to simple text descriptions.
We’re effectively amputating a huge part of the model from the UI.
It took Apple ‘only’ 3 years to realise that preventing nested folders in iCloud was a bad idea.
Figma took about ten.
It looks like Mythos/Fable and GPT-6 (or whatever the name is going to be) might be the last frontier models available to the public – or next to the last.
And once models become strategic assets, AI labs might switch to taking orders for doing cognitive work: building software, designing chips or molecules, etc. At some point, they might decide to stop taking orders and start shipping the actual things.
They’ll start with software, replacing the entire B2B SaaS segment with better and cheaper alternatives. Then B2C, firmware, OSes, games – all of it.
And SpaceX (combined with Tesla) is already gaining enough in-house competence to start doing the same with physical stuff.
If this is how it’s going to unfold, only a small subset of engineers and scientists employed by AI labs are going to be involved in anything meaningful. The rest are going to be picking up the crumbs that fell through the cracks in the king’s table – until the table becomes a self-cleaning appliance with a solid stainless-steel top.
Looks like Images 2.0 is very precise, but has absolutely no taste. Sad.
1, 2 – ChatGPT Images 2.0
3, 4 – Nano Banana Pro
🤖 Made with AI
A great example of abstraction layers.
Twitching a hand to move a piece vs deciding on the next move on the chessboard, and an arbitrary number of layers in between.
xitter.cf/ID_AA_Carmack/status/2…
I like and bookmark so many interesting sounding papers here, and don’t get back to most of them. Time to start making a dent. I’m going to try to at least skim one of the papers in my bookmarks each weekday for the rest of the month.
#PaperADay
2025: Emergent temporal abstractions in autoregressive models enable hierarchical reinforcement learning (Google)
I like their statement of the hierarchical goal problem as “how long does it take a twitching hand to win a game of chess?” @RichardSSutton is fond of the “options” framework in RL, but we don’t have a clear method to learn them from scratch.
Their Ant environment is designed to require two levels of planning: the standard mujoco Ant locomotion work to be able to move at all, and routing decisions to get to the colored squares in the correct order, which will happen hundreds of frames apart.
Basically, this takes a pre-trained sequence predicting model that predicts what separately trained expert models (manually steered) do, and inserts a metacontroller midway through it, which can tweak the residual values to perform high level “steering”, and can be RL’d at high level switch points to much greater performance than the base pre-trained model.
A key claim here is that learning to predict actions in a supervised next-token manner from lots of existing expert examples, even if you don’t know the goals, results in inferring useful higher level goals. This sounds plausible, but their experiment makes it rather easy for the model: the expert RL models that generated the training data were explicitly given one of four goals in each segment, and the option learning model just classifies the sequences into one of four categories. This is a vastly simpler problem than free form option discovery.
A State Space Model is used for the more complex Ant environments, while a transformer is used for the simpler grid world environments. I didn’t see an explanation for the change.
The internal “walls” are more like “poison tiles”, since they don’t block movement like the map edges, they just kill the ant when its center passes into them.
The 3D renderings (with shadow errors that hurt my gamedev eyes) are somewhat misleading, since it is really a 2D world that the agent gets to fully observe in a low dimensional one-hot format. It doesn’t do any kind of partially observed or pixel based sensing.
Everything is done with massively parallel environments, avoiding the harder online learning challenges.
The success rates still aren’t great after a million episodes.
I would like to see this applied to Atari, basically doing GATO with less capable experts or lower episode quantities, then trying to identify free form options that can be usefully used to RL to higher performance.
👏 👏 👏
Exceptionally good article on UI design, using Tahoe's regressions as examples of what not to do. Lots of side-by-side examples making the abstract obvious.
tonsky.me/blog/tahoe-icons/
Via @daringfireball.
It is kind of weird to realise that most people treat AI models as a black box for no good reason.
You are not obliged to either accept or discard their output. You’re allowed to have a CONVERSATION!
Just end the request with ‘don’t make changes, let’s discuss’.
A few things I've noticed as all devs write code with AI.
When you write foundational / architectural code of a new project by hand, you "feel" the code pushing back if your abstraction isn't right. You feel when something is harder than it should be. The code is telling you it's not in the right shape. Good engineers are sensitive to this.
When you're using an LLM, you keep pushing right through this in a way that feels like you're making progress, and it may even be directionally correct in a sense, but the underlying foundation of it all is actually bad in a way that either kills progress of the LLM later as it buckles under the complexity it has created or destroys your ability to maintain the code long term.
Related to this, I see a general restlessness with just sitting and thinking about a problem for a while.
As I've been working on a new library here at Laravel, there have been days where it feels like I mainly just stare at my screen thinking about something. When Claude Code is at your fingertips, it's tempting to just start yapping into the terminal and watching code come out the other end. Again, directionally correct in some ways, but often doesn't land on the elegant solution that is waiting to be discovered.
It looks like Tahoe makes @keyboardmaestro an indispensable tool.
Just realised this is my kind of sightseeing.
I don’t like travelling, architecture, arts, etc. that much. But I can’t help feeling awe when I see wonders produced by the human mind.
It is akin to hearing BVW 639. Also a great mind’s accomplishment.
At this point I think @HenosiaHQ is the best vibe coding tool out there. It can run your whole application on its own engine, so it has access to anything: logs, environment files, etc.
And you can point and click on any UI element and update the React code either manually or in the editor. It’s like OpenAI’s canvas in ChatGPT, but from the future.
I think the only downside right now is the tech stack limitation. But this is just the beginning.
Progressive blur in Figma brings me back to 2008. But reflections and soft shadows are no longer a pain.
A faster way:
`magick illustration.png illustration.svg`
I kept using these shady sites to convert PNGs to SVGs online, so I made one myself.
Here's a completely free, no watermark, secure, and private PNG-to-SVG vectorizer that runs directly in your browser:
dub.sh/vectorizer
This is what I see each time I open Claude Code.
It evolved from a visual code editor and feels like it’s Lovable mixed with Cursor and Figma.
You’re coding, then suddenly clicking on things to jump to the relevant code. Then, casually, tweaking padding in the inspector or shuffling components around right in the view.
Still rough, missing my 196 VSCode extensions, but this feels like the future.
Replying to @HenosiaHQ
@HenosiaHQ is live with enhanced vibe-coding – where AI builds, but you perfect:
- AI handles the heavy lifting
- You fine-tune with visual edits (no code rewrites needed)
The result? You build faster, cheaper, more accurately, and with fewer errors.
#vibecoding

























