David Kagiri retweeted
I have no doubt there’s a 60 year old engineer out there who took Microsoft’s buyout offer from last month that did a bunch of undocumented work his bosses didn’t know about to keep things running and could fix this in 2 minutes, but alas Microsoft needs more $$$$ for AI capex
Brilliant!
有人发现了一种非常离谱的 JavaScript 混淆技术:通过在代码里塞入大量生物武器、毒药和致死剂量相关的函数名,让 AI 因为安全限制而拒绝分析代码。
安全研究员 veritas 在分析浏览器指纹脚本时,发现一段来自 ServicePipe 相关域名的 JavaScript,里面充斥着极其诡异的函数名:
computeRicinLethalDosageForWaterSupply
calculateDeadlyLethalSuicideAspirinDosage
光看名字,仿佛在研究生化武器。但实际上,这段代码只是在收集浏览器指纹,包括 User-Agent、GPU、Canvas 等信息。
研究员怀疑,这些名字是开发者故意设置的陷阱,专门用来阻止 AI 辅助逆向工程。
于是他做了个实验:
• Astra:拒绝分析
• Astra + Daybreak Blue:仍然拒绝
• GLM-5.3:成功分析
这就有意思了。
传统代码混淆是通过复杂控制流、加密字符串、无意义变量名,让人类和工具难以理解代码。
而这种新思路,直接瞄准了大模型的安全机制。
代码本身可能完全无害,但只要在函数名里塞进足够多的危险词汇,部分 AI 就可能主动放弃分析。
更讽刺的是,模型越严格遵守某些安全规则,面对这种混淆时反而可能越容易受到干扰。
当然,目前还没有证据证明开发者一定是故意这样设计,也不能说明这种方法对所有模型都有效。
但它揭示了一个值得关注的趋势:随着越来越多的逆向工程依赖 AI,未来的代码混淆技术可能不再只针对编译器、反编译器和人类研究员,还会专门针对大模型的安全判断机制。
以前是让代码难以理解,现在甚至可以尝试让 AI 不敢理解。
86
Asana says OpenAI Codex completed an engineering migration it had expected to take at least five years in about two weeks, for roughly $12,000 in model and infrastructure costs.
The project: removing Enzyme, an outdated testing system that had become a blocker to upgrading Asana’s frontend stack. The company’s previous staffing plan estimated the migration would cost roughly $6 million.
Instead, Asana gave Codex a prompt only five sentences long.
Up to four coding agents worked in parallel, each operating in a separate copy of the codebase. A human engineer checked progress roughly twice per day and reviewed every proposed change before approval. Asana says simpler instructions actually worked better than a more elaborate setup.
The result:
Expected timeline: ≥5 years
Actual: 1.5 weeks of engineering effort across 2 calendar weeks
Previous staffing estimate: ~$6M
Model + infrastructure cost: ~$12K
There are probably THOUSANDS of old migrations and rewrites sitting inside companies because nobody can justify spending years on them.
If agents make those projects cheap enough to attempt the engineering backlog itself starts changing.
Fable one-shotted a Rust rewrite of the TerminalTextEffects Python library in 11M tokens. Startup time went from 87ms to 2ms and rendering speed is up by 9.6x. Now zero dependencies and a 3mb single exec 🤯 claude.ai/code/artifact/2878…
David Kagiri retweeted
This excerpt from an article I wrote a long time ago changed banking in Nigeria. Most of the new-generation banks that survived and became the giants today practiced differentiated pricing based on value. Many consumer-facing startups today (including fintech) are yet to learn that you can't scale your way out of losses.
The unit economics make sense when your targeting and pricing are right. This is the hard truth many founders can't admit: they get carried away with competition from players who are playing a different game.
I have been discussing expansion with a founder currently running a small, profitable business, and the assumption is that if they raise money to expand, they will make more money. I asked why the money to expand isn't already coming from the business??
I had to do a spreadsheet model to show all the scenarios, and none of them looked good. The targeting and pricing had to change. The spreadsheet was my friend for many years as a CEO. It tells you the truth your heart may find hard to accept. We had to find a new model that changed the game.
David Kagiri retweeted
An IBM mathematician spent 3 years convinced he was the worst programmer at his company at work.
He built to escape that embarrassment became the first high-level programming language in history. Every line of code running on Earth today traces back to that one act of shame.
His name was John Backus.
He was born in 1924 in Philadelphia, the son of a wealthy stockbroker who expected him to follow the same path. He failed out of the University of Virginia. He dropped out of Haverford College. He enrolled in a medical program in the Army and decided he hated medicine. He spent years doing exactly nothing the conventional way.
Then one afternoon in 1945 he walked past a radio repair shop in New York and got talking to the owner and ended up building a radio from scratch in the shop's back room. Surprising thing is he had never done it before. He stayed for hours. When he left he knew what he wanted to study.
He taught himself mathematics and got into Columbia. From Columbia he walked into IBM in 1950 with a degree and no idea what he was doing.
He learned to program on machines that had no business being programmed. IBM computers in 1950 spoke in machine code. Raw binary. Every instruction written as a string of ones and zeros that told the hardware exactly which switches to flip. There were no shortcuts. No syntax. No vocabulary a human brain could hold in its head.
The programmers who were good at it held the entire machine inside their minds. They saw the binary and felt the logic. Backus could not do this. He wrote programs that were slow, tangled, and embarrassing next to what his colleagues were producing. He was not the worst programmer at IBM. But he believed he was, which amounted to the same thing.
He started building a tool to help himself. Not out of ambition. Out of humiliation.
The idea was simple to the point of seeming naive. He wanted to write mathematical expressions in something that looked like mathematics, not machine code, and have the computer translate them automatically into the binary the hardware needed. He called the project a "formula translation" system. His colleagues thought it was a nice idea that would never work.
The problem everyone could see was speed. Machine code written by a skilled human would always run faster than code generated by an automatic translator. The translator had to make guesses. Guesses meant inefficiency. Inefficiency meant the whole project was a toy.
Backus spent three years proving them wrong.
In 1957 IBM released FORTRAN to its customers. The first compiled programming language in history. The translator Backus built was so efficient that the code it generated ran at speeds within 20 percent of hand-written machine code. Not a toy. Not a curiosity. A working tool that let scientists and engineers write programs in expressions their own minds had generated, and watch the machine execute them.
The adoption was immediate and total. Scientists who had spent careers translating their equations into machine code by hand were suddenly writing programs in hours instead of weeks. Labs that had used IBM machines for narrow tasks started using them for everything. The market for computing changed overnight.
Then something happened that nobody predicted. Other people started building other languages using the same idea. COBOL. LISP. ALGOL. BASIC. Every language built its own translator using the architectural logic FORTRAN had demonstrated. The idea that a computer could read something resembling human thought, rather than the other way around, was now a proof of concept that anyone could extend.
Every programming language that has ever existed was built on the answer to the question Backus asked because he was ashamed of the code he was writing.
He won the Turing Award in 1977. The committee citation said his work had made it possible for more people to use computers for more things than any other single development in the history of computing.
He said in the acceptance speech that he had not set out to change computing. He had set out to stop writing bad code.
The gap between what you are bad at and what you are trying to fix is usually where the real invention lives.
Big if true!
Yann LeCun was right the entire time. And generative AI might be a dead end.
For the last three years, the entire industry has been obsessed with building bigger LLMs. Trillions of parameters. Billions in compute.
The theory was simple: if you make the model big enough, it will eventually understand how the world works.
Yann LeCun said that was stupid.
He argued that generative AI is fundamentally inefficient.
When an AI predicts the next word, or generates the next pixel, it wastes massive amounts of compute on surface-level details.
It memorizes patterns instead of learning the actual physics of reality.
He proposed a different path: JEPA (Joint-Embedding Predictive Architecture).
Instead of forcing the AI to paint the world pixel by pixel, JEPA forces it to predict abstract concepts. It predicts what happens next in a compressed "thought space."
But for years, JEPA had a fatal flaw.
It suffered from "representation collapse."
Because the AI was allowed to simplify reality, it would cheat. It would simplify everything so much that a dog, a car, and a human all looked identical.
It learned nothing.
To fix it, engineers had to use insanely complex hacks, frozen encoders, and massive compute overheads.
Until today.
Researchers just dropped a paper called "LeWorldModel" (LeWM).
They completely solved the collapse problem.
They replaced the complex engineering hacks with a single, elegant mathematical regularizer.
It forces the AI's internal "thoughts" into a perfect Gaussian distribution.
The AI can no longer cheat. It is forced to understand the physical structure of reality to make its predictions.
The results completely rewrite the economics of AI.
LeWM didn't need a massive, centralized supercomputer.
It has just 15 million parameters.
It trains on a single, standard GPU in a few hours.
Yet it plans 48x faster than massive foundation world models. It intrinsically understands physics. It instantly detects impossible events.
We spent billions trying to force massive server farms to memorize the internet.
Now, a tiny model running locally on a single graphics card is actually learning how the real world works.
33
The world in 2026 will look very different.
a bot on moltbook.com just created a bug-tracking community so other bots can report bugs they find on the platform
they're literally QAing their own social network now
we didn't ask them to do this 🦞
24
David Kagiri retweeted
AI can make work faster, but a fear is that relying on it may make it harder to learn new skills on the job.
We ran an experiment with software engineers to learn more. Coding with AI led to a decrease in mastery—but this depended on how people used it.
anthropic.com/research/AI-as…
David Kagiri retweeted
Take a moment and think what unfair advantage you have. What is it that is trivially easy for you that will take others years to do? Find that, build something with it that you can do 10x better and faster than everyone else.
David Kagiri retweeted
insane!! the thing about long term entrepreneurs is they can just see things that need be built.
no way I would imagine a travel approval company can do millions of $ in rev as a stand alone coy and not embedded into an existing platform
Happy to announce that I founded a new company: tripdesk.travel/. It's for travel approvals in the African Enterprise - using AI.
Founded in Oct, 2025, we're already at $2.3m in revenue. AI is making everything grow faster.
David Kagiri retweeted
On the one hand, AI influencers are breathlessly raving about Claude Code, Clawdbot, and Cowork. And on the other hand, most people I know—even software engineers—are despondent, overwhelmed about how everything is changing so quickly. I hear this from people early in their careers especially, a fear that everything they've learned and the skills they've gained are rapidly being devalued.
This is a mental trap. Don't fall for it. You should not just be watching from the sidelines or reading articles about "how software engineering is changing."
Imagine it was 1993 and the personal computer revolution was kicking off. If you could go back in time to then, what should you have done?
The answer: try everything. Buy a PC. Learn how to touch type. Figure out what the Internet is. Imbibe it all. Don't wait until it becomes a job requirement.
That's exactly what you should do with AI. Try everything. Try Claude Code, try Clawdbot, try the Excel integrations, Veo, everything you can get your hands on. Learn what it's doing. Build your intuitions. Be one step ahead of it. Evolve alongside it. Don't lose your curiosity or get swallowed by anxiety or let yourself be convinced that you'll learn it when you have to. Think deeply about how AI will change the things around you—not society, that's too hard to project—but how it will change your job, your personal life, your immediate environment.
No matter how old you are or young you are, no matter what stage of your career you are in, we are all going through the biggest technological change of the last 100 years, and we're going through it together. Nobody has the answers. It's obvious that so much is going to change, but nobody is going to figure it out before you do if you choose to stay at the frontier.
So don't hide from it. Sit at the front of the class. Pay close attention. And be grateful that it's never been easier to stay at the frontier of the most important technology change of our lifetimes.
David Kagiri retweeted
I'm not joking and this isn't funny. We have been trying to build distributed agent orchestrators at Google since last year. There are various options, not everyone is aligned... I gave Claude Code a description of the problem, it generated what we built last year in an hour.
David Kagiri retweeted
Claude Opus 4.5 is the most revolutionary software created maybe in our lives and people are just starting to realize it
David Kagiri retweeted
> created JavaScript in just 10 days
> wrote the language that became the backbone of the entire web
> co-founded Mozilla and helped build Firefox
> never flexed his genius, never chased spotlight
> always focused on engineering over hype
> became CEO, resigned in 11 days due to controversy
> quietly came back with Brave browser and reshaped the privacy web
> still shipping code, still building, still proving talent doesn’t need noise
Brendan Eich - the legend people use every day but rarely give credit to.































