Hải

Best proof is your

[Vidit Nanda @viditnanda]

https://t.co/8SQUO0uQ4h

[Samuel Choi @slamthatmule]

https://t.co/JuHOyHPceU

[Kira @Kiiiiira777]

This is f*cking insane. Anthropic CEO Dario Amodei was asked what a kid graduating high school should do now. His answer:

"It will also eliminate jobs, and probably a large number of them"

In 35 seconds, he names who gets hit first: entry-level law, entry-level finance, entry-level consulting

His own prediction: 50% of entry-level white-collar jobs disrupted in 1 to 5 years

Every past disruption gave people time to adapt. He says this one is deeper and coming faster

Prompts → Agents → Harness → Loops → The One Running the AI

His advice: learn to use AI. Using it won't be enough. You need a harness that runs it for you

You can start with repos bellow.

Every repo below is free:

Anthropic's plugins for legal, finance, sales, HR and data work
https://t.co/jGEPPPHPO8

Anthropic's agents for analyst work: models, memos, research notes
https://t.co/z0Wc8GEZDN

Excel, Word, PowerPoint and PDF skills
https://t.co/uNkGTdL5ob

Autonomous financial research agent
https://t.co/jCDzX7VXkC

Deep research agent
https://t.co/KNcPSFTNgw

Full-length research reports
https://t.co/RvUGDnMA2Y

12 principles of agents that actually work
https://t.co/6ADWATJmSW

Batteries-included agent harness
https://t.co/scKVRKPjrt

Claude Agent SDK
https://t.co/GOrg5PBa0K

Agent memory
https://t.co/uAbHeM38Zv

Autonomous agent loop
https://t.co/ruRAvHzxkZ

Browser control
https://t.co/VSfrmN2PRn

Claude cookbooks
https://t.co/CiU71edEWw

Free agents course: 18 lessons
https://t.co/IlVNodhQiG

All of this costs $0

AI won't replace you. Someone with a harness will

95% will keep applying for jobs AI already does, the 5% who build a harness will be the ones running it

Bookmark it and send it to someone just starting their career

Then use the guide below to build your harness before everyone else does ↓

[NoaX @noahatwhere]

I've been thinking about how fundamentally unfair AI research is becoming.

A PhD student at a well-funded lab might have access to hundreds of GPUs, the latest frontier models, and an entire team of engineers.

Meanwhile, an equally talented student at a smaller university might spend weeks waiting for access to a handful of GPUs.

And we're supposed to evaluate their research output as if they're competing on equal terms.

The uncomfortable reality is that AI research is increasingly an engineering and industrial problem, not just an intellectual one.

With enough compute, you can test dozens of hypotheses in parallel, run extensive ablations, explore different architectures, and quickly discard failed ideas.

With limited compute, even validating a single hypothesis can consume weeks.

This changes the nature of scientific competition.

It's not simply that wealthy labs can train bigger models. They can afford to be wrong more often, explore more possibilities, and learn from more failures.

And that advantage compounds.

Better resources lead to better experiments, stronger papers, more recognition, more funding, and eventually even better resources.

Of course, brilliant ideas can still come from anywhere. Compute doesn't automatically produce scientific insight.

But it increasingly determines which ideas get the opportunity to be tested.

I find something deeply unsettling about that.

Science is supposed to be one of the few places where an extraordinary idea from an unknown researcher can challenge the most powerful institutions.

Yet in AI, we're gradually building a research ecosystem where access to capital and compute can matter as much as intellectual ability.

Sometimes being a PhD student with a good idea but almost no compute feels like standing at the foot of an enormous mountain, looking up at institutions you can barely imagine competing with.

And I wonder how many genuinely important discoveries we'll never see, simply because the people who could have made them never had the resources to try.

[Wall St Engine @wallstengine]

Google DeepMind just unveiled Genie 4, its next-generation AI world model, and the demos are pretty impressive.

Unlike a typical AI-generated video, Genie 4 creates interactive environments you can explore and modify in real time.

You can change the weather, introduce objects or characters, and interact with people who move, react, and speak.

It also generates native audio, including ambient sounds and dialogue, while simulating physics and collisions.

Built on Gemini Omni, it uses Gemini's reasoning capabilities to maintain continuity and simulate multi-step events, with potential applications in robotics training, gaming, and filmmaking.

Genie 4 is currently available to trusted testers, with access coming to Google AI Ultra subscribers through Project Genie and select API partners.

[Veles @velesxbt]

Renaissance's Medallion fund is WRONG 49.25% of the time. It still made 66% a year for 30 YEARS.

A trader who's right 60% of the time can't touch it.

This f*cking formula shows why.

I ran the math on both.

Genius, right 60%, 100 trades a year - loses money 1 year in 44.
Medallion's 50.75%, 10,000 trades - 7x the profit, loses 1 year in 15.
Same 50.75%, 1,000,000 trades - 750x the profit, basically never loses a year.

Same edge. Different number of bets. Different fate.

P(losing year) ≈ Φ(−(2p − 1) × √trades)

Being right more often helps a little. Being right by a hair, a million times, is how the best fund in history was built.

The full paper is below. Bookmark before it's buried.

[Matt Dancho (Business Science) @mdancho84]

This is arguably one of the best technical books you can read on how LLMs are trained at scale:

> GPU memory and profiling
> tiling, kernel fusion, FlashAttention
> Data / Tensor / Pipeline / Context Parallelism

You can read the PDF here:

[Rohan Padhye @moarbugs]

In my role as PhD advisor, I'm nowadays just telling my students to pick an important problem:

1. That is not trivially solvable by AI today
2. That is not theoretically unsolvable
3. For which a solution technique will just get better with AI advancements, not obsolete.

[SAIR @SAIRfoundation]

New reset!

Teams are already hitting their weekly limits on Open Math OS, so we’ve reset the limits for everyone.

Keep doing great math!

Apply for Open Math OS:
https://t.co/2xMci7oVql

[Pushkar @86pushkar24]

Be like @poteto 😎

> Grew up in Singapore with no CS background.
> Taught herself design as a teen.
> Studied finance at Monash.
> First program was an Excel VBA macro.
> Failed a startup.
> Started blogging and tweeting while learning to code.
> EmberConf organizers found her tweets.
> Invited her to speak in 2015.
> She was a nobody in Melbourne.
> Shaking through her first talk.
> That one talk changed everything.
> Landed at DockYard. Moved to the US.
> Another talk got her into Netflix.
> Built studio tools. Became a tech lead.
> Then an engineering manager.
> Missed building. Went back to IC work.
> Open-sourced hiring-without-whiteboards.
> Dan Abramov invited her to React at Meta.
> Imposter syndrome. Said yes anyway.
> Six years on the @reactjs team.
> Sole author of the React Compiler Beta post.
> Co-author of React Compiler 1.0.
> Burned out. Took time off.
> Started building agent tools for herself.
> Joined @cursor_ai in 2026.
> Taught agents to verify their own work.
> That became pstack.
> Cursor got acquired into @spacexai.
> Rebuilt Grok Bot.
> Now ships 2,000–2,500 PRs a month.
> Went from 31K to 200K+ followers.
> @elonmusk keeps reposting her.

She didn’t start with a degree or confidence.
She started by writing in public.

Every major job came from people finding her posts.
Now she’s building Grok Bot and still on the React Compiler core team.

She is truly an inspiration. ✨✨

[Jack McCarthy @Jack______M]

Holy cr*p! @kirancodes explains how to get formal program semantics that are provably equivalent to the executed assembly🤯🤯🤯

That’s a real dreamer in action.

Just wait 10 years, every CS student will study her refinement theorem

Only at #LeanNYC

[Hugging Face @huggingface]

Come and build models, datasets, and spaces on the hub, to win $20k in cash and credits!

[SumitX @Sumits_X]

Cracking The Backend Interviews...

https://t.co/fXgc5Jt2ZB

[Thore Graepel @ThoreG]

Ten years ago, AlphaGo’s Move 37 shocked the world.

It wasn’t intuition alone that produced it. AlphaGo could search possible futures, test its instincts and reason about what would happen next.

In a new piece for @techreview, I argue that today’s most advanced AI systems are still missing something fundamental.

LLMs are remarkably capable, but generating longer chains of thought is not the same as genuine reasoning. They typically have no explicit, inspectable record of what they know, what remains uncertain, what evidence supports a conclusion or whether genuine progress has been made.

This is why I recently left @GoogleDeepMind. I believe we need a fresh approach to machine reasoning, drawing on some of the architectural lessons from AlphaGo.

If AI is going to produce trustworthy and genuinely novel insights in science, medicine and beyond, we need systems whose conclusions arise from an auditable process of evidence, inference and belief revision.

[Andrej Karpathy @karpathy]

We'll be spending a lot more time trying to understand the outputs of language models. A few thoughts, tips & tricks:

Writing. Something I've had success with: Ask your LLM to explain something in ASD-STE100, it's a controlled language specification originally developed for aerospace maintenance documentation. LLMs well-versed in this language and it comes with heavy constraints on clean writing style that I often find a lot more readable. Sometimes I've tried to soften it a bit e.g. ask for "80% of the way to ASD-STE100" because the spec is quite stringent. But even better:

Diagrams / images. Instead of writing, ask your LLM to create a diagram. These can be a lot easier to process, parse, and understand. But even better:

Web pages. Ask for output "in HTML" to get a beautiful, interactive webpage. LLMs are getting really good at frontend and can create beautiful experiences, animations, etc. But even better:

Explainer videos. The output format I am most bullish on is fully custom / bespoke explainer videos generated on any arbitrary topic. Experiment with things like "Create a 3b1b style video explainer on X. Use my ElevenLabs API key for audio narration". (you'd need an API key for the latter or you can ask your LLM to find you decent free alternatives that use your local compute). This is actually starting to work!

In summary:
- As LLMs get better, they will do more and more of the legwork autonomously, and a lot more of our work will rise up the abstractions into oversight and understanding.
- Luckily, LLMs can help here too because as intelligence and code are increasingly abundant, you can ask for large, custom, discardable software artifacts (e.g. web apps, video explainers) that would have never made sense to create before. Push the boundaries here and you'll be surprised.

[Chubby♨️ @kimmonismus]

Google says Gemini 4 Argon agents have already freed over 300 TiB of memory across its data centers, with a 1 million token output limit and agents already optimizing its own infrastructure.

The agents analyzed profiling data, found memory optimizations and applied changes that were subsequently rolled out.

Argon agents are also working on C/C++ to Rust migrations reaching 800,000+ lines of kernel code, with extensive audits and testing before deployment.

For its video decoder, Google says agents replaced 32,000 lines of SIMD code with safe Rust, making the existing Rust port 2.7x faster while preserving identical video output.

These are expensive engineering tasks inside infrastructure Google already operates.

This release seems to be a much bigger deal than people think!

[Xudong Han @Xudong07452910]

这篇普林斯顿博士论文，几乎把强化学习过去十年的两条主线串在了一起：

从博弈算法，一路走到世界模型。

作者 Zihan Ding，导师是 Chi Jin。整篇论文超过 300 页，汇集了博士期间八项研究工作，其中多项成果发表于 NeurIPS、ICML、ICLR 和 ICCV。

前半部分研究多智能体博弈：如何学习接近纳什均衡、难以被对手利用的策略，并把这些方法扩展到格斗游戏、多人博弈和真实网络负载均衡。

后半部分转向 Foundation Model 时代：扩散世界模型、生成模型策略、少步视频生成、可交互视频世界模型，以及支持长时预测的记忆机制。

这篇论文最有价值的地方是它记录了强化学习研究重心的一次迁移。

过去，RL 更关注如何在给定环境中学会行动。

现在，Agent 还需要借助生成模型建立对环境的理解，预测不同动作会带来什么未来，再据此规划和决策。

这里收录的也不只是零散的想法，而是一条经过多年研究和多篇顶会论文逐步铺开的路线。

很多论文告诉你某个方法如何提升一个指标。

这篇博士论文更像一张地图，让人看清强化学习如何从策略优化，走向对复杂世界的建模。

想系统理解 RL、世界模型和生成式 AI 之间的关系，这篇很值得完整读一遍。

📎 arxiv: https://t.co/M7rIJ6SKwO

[Spencer Baggins @bigaiguy]

A teenager in the United States started publishing software at 14 in 1998, built the entire online infrastructure for the Occupy Wall Street movement in 2011, joined Google as a software engineer, quit in 2018, and then spent five years writing a C library that does something the entire industry said was impossible.

Then she combined it with llama.cpp and shipped the easiest way on the planet to run a large language model on any computer.

Her name is Justine Tunney.

Here is the story, because almost nobody outside the low level systems world knows what one engineer has built.

Justine was born in 1984. She started writing and publishing software at 14, back when distribution meant uploading binaries to BBS systems and chat networks. She picked up the handle jart, which she still uses on GitHub today. She did the work most teenagers her age were not doing. She read the systems programming literature. She studied compilers. She fell in love with C.

In July 2011 she registered the @occupywallst Twitter handle and the occupywallst dot org domain. Within weeks the protest movement that began in Zuccotti Park in New York had become a global phenomenon, and her infrastructure was the digital backbone of the entire thing. She handled the social media, the website, the donations, the coordination. She built the platform that pushed the movement to reach millions.

After Occupy she joined Google as a software engineer. She worked on TensorBoard, the visualization tool for TensorFlow, and on site reliability for Google infrastructure. She stayed for years. Then in 2018 she left Google Brain to work on a personal project.

The project was called Cosmopolitan Libc.

Cosmopolitan does something most C programmers would tell you is mathematically impossible. It lets you compile a C program once and have the resulting binary run natively on Linux, Windows, macOS, FreeBSD, OpenBSD, and NetBSD with no modification. One file. Six operating systems. No virtual machines. No interpreters. No recompilation. The technique she invented is called Actually Portable Executable.

The implications are wild. Cosmopolitan binaries violate every assumption about how operating systems load programs. They are at once a Windows PE file, a Linux ELF binary, a macOS Mach-O binary, and a shell script. The same bytes run on every platform.

For five years she worked on it mostly alone. She funded the development partly through Mozilla's MIECO program, which sponsored her work on Cosmopolitan 3.0, released on October 31, 2023.

A month later she shipped llamafile.

llamafile is what happens when you combine Cosmopolitan with llama.cpp. You take any LLM weights file in the standard GGUF format, you wrap it in Justine's binary, and you get a single file that runs on six operating systems without installation. No Python. No CUDA setup. No dependency hell. Just one file that you double click and it works.

Mozilla launched it as an official project of their innovation group on November 29, 2023. It went viral immediately. The repository, hosted at github .com/mozilla-ai/llamafile, now has 24,600 stars. The license is Apache 2.0.

Justine kept shipping. She added GPU support to Cosmopolitan, a task systems engineers thought would require rewriting the whole thing. She added dlopen support, another thing nobody else had figured out. She wrote whisperfile, a single file version of OpenAI's Whisper speech-to-text model based on the same architecture.

Her GitHub profile lists projects most engineers would consider impossible. sectorlisp, a Lisp interpreter that fits in a boot sector. blink, the tiniest x86-64-linux emulator on Earth. bestline, a teletypewriter command session library. redbean, a complete web server inside a single zip file.

A teenager who shipped software in 1998 grew up to write the C library that the entire local AI movement now runs on top of.

She did most of it alone, and most people scrolling AI Twitter cannot name her.

[Tomas Vykruta @tvykruta]

I spent years in C and C++ at Microsoft and Google and architected 100s of systems and reviewed 1000s. I smell bad code the way some people smell smoke.

1/ First week with Claude I thought I’d cheated the system — stuff shipped, checks went green, I went to bed early.

Then every bug fix started making two new ones. Work crawled.

2/ Checkout breaks billing. Billing nukes notifications. “Quick field tweak” blows up three modules.

I saw the same Spaghetti code lazy programmers have always written — Claude just writes it 200x faster.

3/ Anthropic trained a genius on a landfill of Stack Overflow and enterprise Java and called it helpful.

Reach through objects. Over-DRY. Speculative hooks. Inheritance trees. One file, five jobs. God functions.

4/ Fix has been here since 1994. Anyone recognize this?

5/ Steal — paste into `AGENTS.md`:

```
# Timeless constraints (not a checklist)

When two principles collide, pick the one that cuts future cost in THIS codebase.

HARD RULE: refactor to the principle FIRST, then change behavior.

1. Separation of Concerns — one kind of work per part (UI / domain / persistence / infra). Root principle.
2. Encapsulation / Information Hiding — small stable contract; hide internals.
3. High Cohesion + Loose Coupling — change-together lives together; independents talk narrow.
4. DRY — one authoritative representation of each piece of *knowledge* (not every similar line). Avoid over-DRY.
5. KISS — simplest design that works; complexity is the long-term tax.
6. Single Responsibility — one reason to change.
7. Depend on Abstractions — policy doesn’t depend on details; both depend on contracts.
8. YAGNI — no speculative features, frameworks, or “later” hooks.
9. Composition over Inheritance — assemble pieces; don’t grow fragile hierarchies.
10. Open/Closed (with discipline) — extend at stable boundaries; only where change showed up twice.

Honorable: Law of Demeter · fail fast / illegal states unrepresentable · optimize for deletion · Unix do-one-thing + compose.

Treat as constraints. Violate slogans when judgment says so.
```