“the AI guy” at MGX. I try a new software every day. ex. EQT Motherbrain, Spotify, KPMG, Accenture
Stockholm, Sweden
Joined April 2009
- Tweets715
- Following2.8K
- Followers293
- Likes1.4K
With the emergence of AI coders doing most of the work, I predict a future where it writes correct code with much less guardrails. In fact languages designed for addressing human flaws will be displaced by AI first programming languages, closer to the metal.
Pietro Casella retweeted
narrative violation: preferences will swing back from DIY vibe-coded software to super secure industry-leading SaaS solutions.
while it's super easy to build anything, endlessly protecting and securing it is super hard...and teams want to sleep at night.
Very important development. Formal verification is the holy grail for high risk systems like flight control, medical devices, power plant controllers and more.
Prediction: after all easy software is refactored, cracked engineers will mainly find joy building very complex systems that were not possible before.
… so best time ever to be or become one.
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…
38
Vercel now has all the pieces in place to host at-scale backends.
WebSockets, Queues, Workflows, Cron, Services, Containers, Python, Daemons, Long-duration Functions, Blob, Drives, Sandbox…
Any guesses what comes next?
WebSocket support in Vercel Functions is now generally available.
Vercel now serves 15 million WebSocket connections a day across AI chat, streaming, and realtime multiplayer apps.
vercel.com/changelog/websock…
Predicting possible consequences of good interpretability research:
- LLM API will have concept suppression and boosting controls instead of fine tuning.
- LLM will ship and be priced by subdomains/ cognitive subsets.
- inference acceleration and iq focus by lobotomy instead of quantization/distillation.
有点震撼。。。我们可能真的快要搞清楚大模型内部到底是怎么运作的了。
OpenAI早期机械可解释性研究的参与者，昨天突然提出了一个很大胆的结论：
我们可能一直误解了神经网络。
昨天， @nickcammarata 发了一篇很有意思的文章，叫《Neural Networks Are Already Clean》。
这哥们早年就在OpenAI做机械可解释性研究，2023 年还牵头启动了@OpenAI 第一个大规模自动化神经元解释项目。
当时他们发现，现有工具只能解释大约 2% 的神经元。
Nick因此得出了一个很悲观的判断：神经网络内部存在大量纠缠，想搞清楚它们到底在干什么，可能非常困难。
结果三年后，他带着更先进的工具和Agent重新研究，发现情况完全不同。
在他们测试的现代视觉模型中，最后一层 99%～100% 的神经元都能找到相当清晰的解释。
甚至在Qwen3-32B这样的语言模型中，初步研究也发现，约90%的神经元都有一个可以识别的主要功能。
最有意思的是，他还重新研究了过去的一些经典案例。
比如曾经有一个神经元，既会对猫脸产生反应，也会对汽车前脸产生反应。
以前大家觉得，这是典型的Superposition，多个不相关的概念纠缠在了同一个神经元里。
结果重新研究后发现，这个神经元可能只是在识别一种共同的V形视觉结构。
猫脸和汽车前脸恰好都有这种特征。
全世界的家人们折腾了这么多年，可能连最基础的观察方式都有问题。
而且我觉得这篇文章最值得关注的，其实是他们使用 Agent的方式。
他们让Agent自动观察神经元、提出功能假设、设计实验、分析电路，再通过新的输入验证假设，甚至自动审查了10 万张神经元归因图。
这其实也是我最近一直关注的一个方向：让 AI 自己去做科学研究，把大量观察、假设、验证的工作自动化。
过去需要研究员花大量时间逐个分析的神经元，现在已经可以让Agent成规模地开展研究了。
当然，目前这些结果还处于早期阶段，距离完整解释大模型的内部机制，还有很多工作要做。
但我觉得Nick提出的这个观点非常有意思：
神经网络内部可能一直都很有规律，只是过去我们的工具太原始，根本看不清楚。
如果这个方向最终被验证，机械可解释性领域过去很多基础假设，恐怕都需要重新审视了。
3
63
This is an insane way to solve business process automation. It will always be expensive (you're burning tokens for each click and form) and brittle (because it can easily decide to take a different path.)
You *do* want to encode the business standards. You do want to make it repeatable. You can do all that right now by installing swamp, describing your problem, and letting it build the behaviors for you. Have a process you really can't get done any other way than clicking a screen? Fine! Build a behavior for that. But 99% of those processes aren't that. Here's a case study as an example:
swamp-club.com/case-studies/…
They automated a long running, complex on-boarding process that spanned multiple teams, enterprise software platforms, and custom in-house solutions. It just works. It scales. You can reason about it every step of the way.
Doing it the way this proposes? It's like taking the worst instincts of historic RPA and saying it'll all get better because you'll spend thousands of dollars each time on tokens.
We spent decades putting business processes into software. But what connects those systems is still a person with 20 browser tabs open, copying and pasting.
A human API.
My request for startups: computer use agents that actually finish the job. Agents that companies can trust to do real work at scale, and that work in the software companies already use.
If you're building this, we want to hear from you!
More below.
cc @a16z @speedrun
We spent decades putting business processes into software. But what connects those systems is still a person with 20 browser tabs open, copying and pasting.
A human API.
My request for startups: computer use agents that actually finish the job. Agents that companies can trust to do real work at scale, and that work in the software companies already use.
If you're building this, we want to hear from you!
More below.
cc @a16z @speedrun
Introducing generative UI for the agentic era 🤯
no apps. no dashboards. every screen is generated the moment you ask, reshapes as you talk, then disappears.
try now at agently.dev/access
Introducing Hark Pro
Hark Pro is now live on web, iOS, and Android
Try it free: hark.com
I think of models as a mildly in the spectrum, engineer polymaths. Half my prompt input is nuance. Maybe that’s the human part of the equation. But i have great hopes for a knob to modulate that.
Prediction: next generation of models will be a renaissance or Affective Computing and Symbolic AI (inference)
one of the worst things about the newer frontier models
is that they are so RL-fried into always writing code that any question is assumed to be an instruction
and they immediately start making changes
"why does X work like Y"
> "it shouldn't, let me do Z instead"
???
3
49
> meals logged in 5s or less
> super accurate
> predicts your next meal for 1 tap log
> precise macro targets based on apple health
> pulls from databases and restaurant menus
> log with 1 word and it will fill gaps with questions
> clean UI
> FREE
apps.apple.com/us/app/ore-ca…
I couldn't find any recent and reliable comparisons of how good frontier LLMs are at coding in different programming languages.
I'm thinking: If I stopped reading code a year ago and don't see any issues with that, why would I still use Python as the basic language in my app? Why not switch to pure C or Rust or whatever is the fastest option these days?
But I of course am not ready to tolerate a drop in the LLM's capacity to solve problems if the language changes.
Did you see any convincing research/benchmarking of this?
Because you and your AI should speak the same language, the one you love, know the best and have developed taste on. the one you can micromanage when needed and be opinionated about, or ready to deep dive when your buddy gets stuck.
Now you can go and learn new things together that’s fine and more fun than ever but but intentionality is important even then.
AI writes it but you should feel it’s yours to the bones otherwise what’s the point of everything?
2
331
More thoughts on Jev.
1. It cannot be faster to decision than an LLM and be as good. The time an LLM takes until it prints the first token of the answer is equivalent to the compute spent on making a decision. So, if Jev takes less time to output its full output than it takes for an LLM of equivalent size to print the first token, Jev automatically loses in quality.
2. You can get the same classification speed from an LLM if you do the following:
Let's say you have 3 options you want to evaluate.
1) Prepare 3 separate requests to an LLM, where each request has the same question and only a single option of the three. For example:
- "What color is this dress? Output a single number between 0 and 9 to tell how likely it is that it's RED."
- "What color is this dress? Output a single number between 0 and 9 to tell how likely it is that it's GREEN."
- "What color is this dress? Output a single number between 0 and 9 to tell how likely it is that it's BLUE."
The part right before the COLOR ("What color is this dress? Output a single number between 0 and 9 to tell how likely it is that it's") is the same and is in the KV cache. Then, in parallel, you send only the COLOR word to the LLM and only get from it the very first output token, which will be a number between 0 and 9.
2) Now, you have three numbers, say [2, 3, 9]. You use softmax to convert them to probabilities:
[0.09%, 0.25%, 99.66%]
If you call the LLM with thinking disabled, you get your prediction time as the time of the embedding of the common part of the payload (very fast) + the addition of a single answer option to the KV cache (very fast) + generation of a single-digit output (very fast).
If you enable the thinking, it will take more time to generate the thinking tokens, but the quality will be way better than Jev.
Good take. Reminded me of when Back in the day folks would have discussions about programming languages performance. Typed / not typed. Compiled / interpreted. Usually it landed that more abstract languages, given the right hints like typing or directives would achieve parity. leveling the abstraction level leads to parity.
So Jev vs LLM debate… they’re just different tools with different properties. With the right hints as you correctly suggest, they can achieve pretty much the same thing.
The biggest contribution of Jev was introducing folks to a new design pattern/paradigm that of AI for decision making… which btw anyone that worked in credit, fraud or insurance has seen some form or shape of preety much the same pattern on older tech.
2
513
My response to this: xitter.twitterapi.xyz/pietrocasella/status/2…
@thorstenball Great list. Some of my views are slightly different, here are my counter predictions, line by line.
“Code review will die. “
Code will evolve. New domain specific abstractions will be formed to allow some degree of control of what is architected. Humans will interact with abstractions not code directly. Maybe non readable code will rule. Maybe more semantic sugar will be added to manage increasingly large code bases.
“Unit tests might die too”
Testing will evolve to be more extensive and faster, more vertical (many layers). Testing will be behavioral. Cyber testing will be 90% of the testing surface.
“The craft of writing code will disappear. “
Like musicianship post software, coding will prevail as a form of human activity not a necessity. More Humans become virtuoso level than ever because they can now touch more parts of the stack and do more complex things.
“The craft of building software will be more important than ever. “
💯
“Most bugs won't be "coding" bugs. “
💯
“Open source in its current form doesn't make sense anymore.”
💯
“Performance critical contributions by humans will stay what they are: an edge case.”
Except when new much more complex software becomes the norm. Software allways expanded to occupy all available compute. This time it will be the same, expectations will rise, and with that new performance problems too.
“The terminal is dead.”
I think chat and terminal will fuse. CLI as a distribution mechanism will continue to be the norm to enforce APIs. Terminal will become UI. Terminal willl become conversational. All because developing it becomes free.
“Tokens are the new computing paradigm. “
Yes, but this is temporary language. Software will shortly evolve to uncover new more interesting paradigms due to exponential innovation. Tokens will then be just another type of assembly no one cares about.
“The triad of PM/Design/Eng will disappear. “
I think this already is the case. It survives this generation, then the jobs will merge for sure.
“The difference between software engineering at large corporations and small ones will increase. “
Large teams will disappear. Only small ones will survive. Eng size will be equivalent to legal team size but more dominant.
“There's no proof that "good code" will matter in the future.”
I think we will find that good software architecture will be the main requisite for achieving complexity that scales.
“Some people will be priced out of producing software. “
💯 also, total cost of developer will be come the key metric (salary + tokens)
“It's questionable whether cheaper models will be used. “
Price will just remain tiny dimension of a broader decision spectrum: Models will differentiate by many things: benchmark, speed, domain, provenance, TTFT, features, and so much more…
“Models will become so fast that UI will be generated on the fly.”
💯 but designers will define the archetypes and pin them so the concept of affordance still applies and is leveraged.
3
53
@thorstenball Great list. Some of my views are slightly different, here are my counter predictions, line by line.
“Code review will die. “
Code will evolve. New domain specific abstractions will be formed to allow some degree of control of what is architected. Humans will interact with abstractions not code directly. Maybe non readable code will rule. Maybe more semantic sugar will be added to manage increasingly large code bases.
“Unit tests might die too”
Testing will evolve to be more extensive and faster, more vertical (many layers). Testing will be behavioral. Cyber testing will be 90% of the testing surface.
“The craft of writing code will disappear. “
Like musicianship post software, coding will prevail as a form of human activity not a necessity. More Humans become virtuoso level than ever because they can now touch more parts of the stack and do more complex things.
“The craft of building software will be more important than ever. “
💯
“Most bugs won't be "coding" bugs. “
💯
“Open source in its current form doesn't make sense anymore.”
💯
“Performance critical contributions by humans will stay what they are: an edge case.”
Except when new much more complex software becomes the norm. Software allways expanded to occupy all available compute. This time it will be the same, expectations will rise, and with that new performance problems too.
“The terminal is dead.”
I think chat and terminal will fuse. CLI as a distribution mechanism will continue to be the norm to enforce APIs. Terminal will become UI. Terminal willl become conversational. All because developing it becomes free.
“Tokens are the new computing paradigm. “
Yes, but this is temporary language. Software will shortly evolve to uncover new more interesting paradigms due to exponential innovation. Tokens will then be just another type of assembly no one cares about.
“The triad of PM/Design/Eng will disappear. “
I think this already is the case. It survives this generation, then the jobs will merge for sure.
“The difference between software engineering at large corporations and small ones will increase. “
Large teams will disappear. Only small ones will survive. Eng size will be equivalent to legal team size but more dominant.
“There's no proof that "good code" will matter in the future.”
I think we will find that good software architecture will be the main requisite for achieving complexity that scales.
“Some people will be priced out of producing software. “
💯 also, total cost of developer will be come the key metric (salary + tokens)
“It's questionable whether cheaper models will be used. “
Price will just remain tiny dimension of a broader decision spectrum: Models will differentiate by many things: benchmark, speed, domain, provenance, TTFT, features, and so much more…
“Models will become so fast that UI will be generated on the fly.”
💯 but designers will define the archetypes and pin them so the concept of affordance still applies and is leveraged.
I was wrong
I still think it's just an API though and any API can be used as an MCP and in the end they'll just become the same
