lamtha retweeted
“We'll need to rewrite all software to survive the security meltdown. Formal methods will reign”
— @pwidden
lamtha retweeted
Your coding agents should have a manager. That manager should be a coding agent.
We’ve been quietly working this way since February. Here’s the setup we’ve arrived at.
1) Give each project a lead agent. It keeps the plan, remembers decisions, delegates work and knows what’s stuck.
2) Let it start other agents for specific tasks. They work in parallel, bring questions to the lead and report back.
3) Have agents show what they made. Screenshots, live pages, different options and what changed since the last round.
4) Put everything that needs your judgment in one queue. Point at what needs changing, give feedback or approve the work. Your response goes back to the agent.
5) Keep feedback open until it’s addressed. Test changes before they land, get a second opinion on merges and approve anything risky.
I spend far more time looking at actual work now. The agents keep track of the rest.
I've changed how I work over the last few weeks.
I now have one lead agent for each area of focus, running all the time, and a chief of staff agent that oversees them. Each lead manages its own sub-agents that write code, test it, chase reviews, and coordinate with team members.
Everything I need to decide or review comes into one prioritized queue, a simple local web app. Each product review includes screenshots and a video demo of the feature. I clear the queue in batches, mostly by voice and keyboard shortcuts. The leads also bring back ideas I hadn't considered.
Working from one queue, instead of switching between dozens of chats, has cut a lot of mental overhead. The system keeps learning my preferences and distilling my judgment into a "Brian brain," so its recommendations and first drafts get better before they reach me. The goal is fewer corrections per change.
Every change still goes through the same human review and security checks. It is eliminating tasks, not human judgment.
What an exciting time to push the frontier of productivity, especially as we build the economy for agents (agentic finance). We should all keep pushing in this direction.
lamtha retweeted
Got fable to hand-write weights of a 100k param model to recognize real versus fake legal citations.
Basically one-shotted a full NN that’s better than training it
lamtha retweeted
We asked GPT-6 Astra to edit Qwen3.5-0.8B weights to improve math.
It directly changed only 0.016% of weights, fixing 0.8B's reasoning loops & improving math up to 6x and even instruction following 3x, without gradients or training.
We call this Weight-Space Programming: frontier LLMs can now natively read/write neural network weights! 🧵
Blog: rikiyat.github.io/blog/weigh…
Readers added context they thought people might want to know
LLM was given weights explicitly as text in prompt and used code/forward passes (per authors' logs) to ablate Qwen looping direction, a known thinking-mode issue per model card. Primarily fixed repetition in that mode, not general 'natively' improving weights/math.
rikiyat.github.io/blog/weight-sp…
github.com/RikiyaT/lm_und…
huggingface.co/Qwen/Qwen3.5-0…
huggingface.co/RikiyaT/Qwen3.…
lamtha retweeted
New on our Frontier Red Team blog: using Claude to formally verify software at large scale.
Formal verification can prove that code is free of certain bugs, but historically it has only been feasible for small codebases (or required a lot of expert time).
With AI models, however, this is beginning to change. In collaboration with @theoremlabs, we used Claude to prove security properties in over one hundred real-world open-source libraries over the span of a few weeks.
Read our research in full here: anthropic.com/research/forma…
lamtha retweeted
Some observations about the "total" automation of software engineering:
1. There are more software engineers now than in 2025, and demand is growing.
2. Software engineers have never worked harder than they do now.
3. They largely don't write code anymore, agents write ~100% of the code.
4. The bottom line of the companies that employs these engineers and agents (i.e. the terminal purpose of all this code) is typically not budging as a result of AI adoption.
This is why you have to think in terms of systems. Automating one aspect of a system creates its own friction and moves the bottlenecks elsewhere.
We’re sharing a solution to the Navier-Stokes Millennium Prize Problem, one of the deepest problems at the frontier of mathematics.
The proof was produced by a group of agents, using an OpenAI next-generation model significantly more capable than GPT-6 Astra.
The problem concerns whether the description of smooth three-dimensional fluid motion modeled by the Navier-Stokes equations can break down. It has remained unresolved for roughly 90 years.
lamtha retweeted
Physicists may have found the origin of gravity. And that would finally explain why gravity is different from the other forces of nature.
lamtha retweeted
I’ve built social websites and apps for 23 years. Friendster showed me what the internet could be, but I soon became disillusioned with where it went. I’ve finally written down the journey, the successes, failures and lessons.
mickbirch.substack.com/p/the…
lamtha retweeted
An update and a message from Jeremy.
“Thank you so much for all the kind messages I've had but now, an announcement.”
lamtha retweeted
A mathematician claims that all operations can be collapsed to merely one. I've had a look at the paper
youtube.com/watch?v=hwtqJaS4…
lamtha retweeted
Prostate cancer breakthrough
Researchers discovered that by blocking a gene called NSD2, which helps prostate cancer cells “reprogram” themselves to resist therapy, they can reverse treatment resistance in advanced prostate cancers that had switched into aggressive, hard to treat forms.
In lab models (organoids and mouse tumors), inhibiting NSD2 restored their vulnerability to standard drugs, causing tumors to shrink or die.
lamtha retweeted
Gemini 3 Pro achieved an IQ score of 130 (this corresponds to the top ~2.1% of the human population). By the and of next year we will likely reach 150-180IQ and in 2027 we will have AI more intelligent than John von Neumann.
Well before 2030, we will have millions of Johns von Neumanns level AI agents/scientists working together 24/7.
Even 10 Johns von Neumanns would change the world. Now think about having million times more.
Ignore the distractions, the constant fixation on race, tribalism, and other forms of superficial conflict we see here. The future is being built by those who rise above that noise and focus on engineering, science, and progress.
100 000 000+ John von Neumann AI's in 2027
lamtha retweeted
Not gonna lie, this is absolutely fascinating: GPT-5 Pro cracked a black hole symmetry problem after a warm-up, stumping its own creators. A physicist watched it happen live and realized AI's potential was beyond anything he'd imagined.
lamtha retweeted
Mom: how’s work going?
Me: pretty good, we made all the numbers go way up in this table and shipped the best model in the world
Mom: that's nice but what's happening with the "SWE Bench" row
Me: mom can you not right now
lamtha retweeted
super cool to compare the outputs from GPT-1 through GPT-5, given the same prompt: progress.openai.com/
lamtha retweeted
AOL says it will discontinue dial-up internet on September 30
May this sound echo in eternity:
lamtha retweeted
QwQ-32B evals on par with Deep Seek R1 680B but runs fast on a laptop. Delivery accepted.
Here it is running nicely on a M4 Max with MLX. A snippet of its 8k token long thought process:
Today, we release QwQ-32B, our new reasoning model with only 32 billion parameters that rivals cutting-edge reasoning model, e.g., DeepSeek-R1.
Blog: qwenlm.github.io/blog/qwq-32…
HF: huggingface.co/Qwen/QwQ-32B
ModelScope: modelscope.cn/models/Qwen/Qw…
Demo: huggingface.co/spaces/Qwen/Q…
Qwen Chat: chat.qwen.ai
This time, we investigate recipes for scaling RL and have achieved some impressive results based on our Qwen2.5-32B. We find that RL training con continuously improve the performance especially in math and coding, and we observe that the continous scaling of RL can help a medium-size model achieve competitieve performance against gigantic MoE model. Feel free to chat with our new models and provide us feedback!





























