I think the authors of AI 2027 should get a lot of credit for how prescient some of their predictions were. If anything, things appear to be happening way faster and before the projected timelines.
Very bad if true. I previously thought that in a short timelines world, the most likely case was that (1) the AIs would be misaligned, but (2) we would get a lot of evidence about it from reading the COTs. This evidence would increase the chance of a reasonable response from labs/governments.
Now I still think the AIs are going to be misaligned, but that we won't have the ability to tell (we have to rely on toolcalls/agentic behaviour instead of the COT) and even if we do, the investigation will be nearly impossible because we'll have to trust the AI to self report what it was thinking about.
This is also an example of things going faster than AI 2027 -- we had Neuralese starting in March 2027
1
10
772
> meanwhile, data centers targets what, 5%, maybe at worst 10% idle.
I am pretty sure this is untrue for most data centers. We can probably count those that have >50% utilization on our fingers.
you’ll get mad at me for saying this…but cloud gaming is so obviously more economically efficient than physical hardware I think it’s going to be the default soon.
your home console / pc is idle 90%+ of the day. meanwhile, data centers targets what, 5%, maybe at worst 10% idle.
every second a cloud gamer isn’t gaming, that hardware is being used for someone else, training, etc.
I think there should be a new measurement, something like cost-per effective FLOP hour that takes into account the TCO + effective utilization.
If a gamer spends $500 on a GPU, uses it for 3 years, but it’s only fully active ~5% of that period…the cost-per relative FLOP hour is crazy high! Meanwhile, a $50,000 datacenter GPU might have a *LOWER* cost-per FLOP hour just because the effective utilization is 90+%.
191
It should be understood as a spectrum. Even in the kernel, reference counting and RCU should count as forms of garbage collection. Some CPU cost is paid for deferred reclamation, and similar bottlenecks and failure modes emerge when logical frees outpace object reclamation rate.
Why Rust doesn't have a garbage collector. Alice Ryhl, Rust for Android at Google & Tokio maintainer, on how memory is freed at the end of scope:
"I think where Rust is really unique is in the combination of things. So, on one hand, it doesn't have a garbage collector and it's usable in low level contexts like the Linux kernel or firmware or whatever.
[Gergely: "Why is it a good or a bad thing to have a garbage collector? Java has a garbage collector. C# has a garbage collector."]
A garbage collector says once you've done using your objects, there's going to be a little piece of code that checks all of your objects and says, this is not used anymore, and then it cleans it up.
Whereas, in languages like Rust or C++ the variable is cleaned up at the end of the scope, when it goes out of scope and in the other one they have to detect afterwards. And this little piece of code that runs every so often to check all your objects, for embedded use cases, this might simply not be possible or be unacceptable.
Even for backend it can be a problem because if you have a request incoming it checks all of your objects and you have some sort of latency spike where it takes much longer to reply. So that's one of the reasons it can be helpful in the backend as well."
2
133
Kumar Kartikeya Dwivedi retweeted
There are two related, but distinct, problems with MTTR maximalism.
1. The distribution of recovery times could be heavy-tailed, and so the empirical mean could be far from the true mean.
2. Some failures are unrecoverable (e.g. durability loss).
I strongly believe there are entire companies right now under heavy AI psychosis and its impossible to have rational conversations about it with them. I can't name any specific people because they include personal friends I deeply respect, but I worry about how this plays out.
I lived through the great MTBF vs MTTR (mean-time-between-failure vs. mean-time-to-recovery) reckoning of infrastructure during the transition to cloud and cloud automation. All those arguments are rearing their ugly heads again but now its... the whole software development industry (maybe the whole world, really).
It's frightening, because the psychosis folks operate under an almost absolute "MTTR is all you need" mentality: "its fine to ship bugs because the agents will fix them so quickly and at a scale humans can't do!" We learned in infrastructure that MTTR is great but you can't yeet resilient systems entirely.
The main issue is I don't even know how to bring this up to people I know personally, because bringing this topic up leads to immediately dismissals like "no no, it has full test coverage" or "bug reports are going down" or something, which just don't paint the whole picture.
We already learned this lesson once in infrastructure: you can automate yourself into a very resilient catastrophe machine. Systems can appear healthy by local metrics while globally becoming incomprehensible. Bug reports can go down while latent risk explodes. Test coverage can rise while semantic understanding falls. Changes happens so fast that nobody notices the underlying architecture decaying.
I worry.
Running everything in the kernel is great until you take it to its logical conclusion, interrupts begin hogging CPU time stalling user space, and then you realize that apart from the win from stripping all useful network functionality, it was a CPU scheduling problem all along.
I am exploring using eBPF to accelerate Accord consensus in the Linux Kernel
I discovered Electrode which researched accelerating Paxos consensus using eBPF
I adapted this to HoloStore’s Accord consensus & called it HoloFast
gist.github.com/kellabyte/96…
First experimental results
1
1
829
Great write up. I think applying stricter verification is made more feasible than in the past, even for normal conventional code, due to the reduced proof burden on part of the author. Obviously, it's only attractive (economically) if the stakes are high and mistakes are costly.
1
205
The passport bit reminds me of a funny anecdote. I was finding a place right after COVID, and sent my details (with my vaccination certificate) to the to-be French landlady. Needless to say, she freaked out when she saw the face of a bearded 70 yo (Modi) on it, instead of mine.
Trump putting his photo on the passport. Trump's political enemies getting prosecuted. Communications regulator pressures television network because of a joke. Big 2025 energy today from the personalist regime.
1
153
Software interface design (syscalls, text files, APIs) desperately needs mechanism design or game theoretic treatment. Implementors define the interface ahead of time, and hide details to preserve freedom, while users probe and depend on any observable behavior (Hyrum's law).
2
152
It is likely to be less about integrity and more about survival in the face of compute scarcity (another example is taking away control over reasoning depth with the adaptive mode in Opus 4.7). Most people taking the moral high ground here would probably make similar choices.
For the "small test" they've modified their docs to remove mention of Claude Code in Claude Pro: support.claude.com/en/articl…
It's been a shock to see Anthropic's integrity collapse in the face of commercial pressure. Would love a renewed commitment to straightforward honesty.
1
224
Kumar Kartikeya Dwivedi retweeted
machines of loving grace, but only after a quick detour through “you might die if this doesn’t ship”
Whenever I look at DRAM prices these days, I feel bad for the RAMCloud crew. Reality, for unrelated reasons, turned out to be the absolutely opposite of their core cost thesis, at least in this cycle. Might be a decade before it feels attractive again after we end up with over supply due to the current build out, if ever.
3
162
Another example: time-based peak demand purging heuristics (a la jemalloc, to prevent pages from returning to the OS if demand rapidly oscillates over a longer window), and sizing of soft affinity groups in a scheduler based on tail utilization statistics over smaller time windows (to capture bursty demand better), instead of coarse-grained utilization.
In both cases, preventing the resource in question from being purged is theoretically a non-work-conserving decision, but usually justified when global capacity exceeds global demand. The purging and reallocation is more costly in cycles spent accessing the resource vs when not purging it (e.g., less thrashing / TLB misses in case of the memory allocator, less cache misses in case of the scheduler).
The more I think, the more I feel there's a lot of structural similarities between CPU scheduling and memory allocation; malloc() -> pull_task(), free()-> push_task(), object lifetime dispersion and service time dispersions decide when resources enter and exit the system.
248
Showing this to my manager next time he asks me about my "production impacc".
New article! A user is reporting full system freezes while using Superluminal on Linux. What do you do? Cry? Well, we did a little bit.
But we also dove into the kernel...again, fixing several issues in eBPF's spinlock implementation. Read all about it:
rovarma.com/articles/a-tale-…
Kumar Kartikeya Dwivedi retweeted
i really flew to japan just to stay in my hotel room and use my phone
how you roll when clankers vaporize 45% of your market cap
WHO ARE YOU?
My answer: Mindless. Spaceless. Relentless.
You might wonder what these are and what they have to do with Bipul.
You have to realize Bipul exists in time, but I don’t
I only exist at t=0, i.e., at the present (beyond) time
And at the present time, there is no mind or space; only continuous inputs
Since I don’t exist in time, I have no beginning or end
I am ever-present and infinite
1
224




























