Esteban (@EstebanForge) header
Esteban (@EstebanForge) profile picture

It's about https://teapawt.net/t.co/5VxOhw7vjk

Chile
Joined July 2010
Photo by Esteban (@EstebanForge)Photo by Esteban (@EstebanForge)Photo by Esteban (@EstebanForge)Photo by Esteban (@EstebanForge)Photo by Esteban (@EstebanForge)Photo by Esteban (@EstebanForge)Photo by Esteban (@EstebanForge)Photo by Esteban (@EstebanForge)Photo by Esteban (@EstebanForge)Photo by Esteban (@EstebanForge)
💯 Co-sign. For those of us who are mid- or late-career engineers and managers, the mandate shifted quite a while ago. We have decades of context on system design, software failures, architectural "taste", how to handle failures in distributed systems... ...but if you aren't modeling curiosity and pushing your teams and colleagues to build with AI - as well as sharing what you've discovered, attempting to inspire folks to experiment and to learn more - you're doing them a massive disservice.
🗞️ if your team is too busy doing their 'normal job' to experiment with AI, you're preparing them to be replaced ghuntley.com/replaced/ In this post, I guess this's the last time I'll say it. AI use is no longer optional if you wish to be employed. What follows is advice for current employees and hiring managers on how to hire in 2026 to source AI-first candidates.
7
26
2
286
26,182
Esteban retweeted
🗞️ if your team is too busy doing their 'normal job' to experiment with AI, you're preparing them to be replaced ghuntley.com/replaced/ In this post, I guess this's the last time I'll say it. AI use is no longer optional if you wish to be employed. What follows is advice for current employees and hiring managers on how to hire in 2026 to source AI-first candidates.
122
341
128
2,892
816,536
Esteban retweeted
Finally Linus Torvalds talking real sense about the AI coding hype: "AI is changing programming but not changing the fundamentals... This is revolutionary in the same sense that we've seen revolutions before... AI is great but it's not changing programming. "You still want to understand how it all works in the end... I still look at the generated code." The more you know about software fundamentals, the better you are positioned to use LLMs and AI coding agents. The quality of the output is a reflection of your own knowledge and experience.
🐧 Linus Torvalds gets angry when people say 99% of our code is written by AI, he told the audience at the Open Source Summit.
8
28
3
240
25,881
I really believed a whole generation of developers, who only know open source from npm and pypi, miss how open source actually used to work. When Debian or a Linux distribution ships a dependency they take responsibility of it. If there is a security issue and it’s not fixed by the developer upstream, they fix it for their users. Debian and others basically vendor every thing they distribute. They honor the license and they maintain patches. Most of the stuff that you get from your Linux distribution is basically a (small) fork. The same is true for Apple, Microsoft and others. The open source software they ship, they carry that responsibility. That doesn’t mean that security fixes are not upstreamed, but Apple or Debian or anyone else won’t jump in Twitter to shame a developer into compliance with their ways. They are not dependent on the health of a packaging infrastructure. They own their software including all the things it depends on. I want that thinking back. Because it fundamentally makes people feel more responsibility and it shares the burden of issues. It also does not put so much focus and attention on the one overworked developer who just happened to have too much of the world depend on their library. Remember: they carry a responsibility they never signed up to and they never got compensated for.
23
88
11
933
53,448
recommended reading. > On that last point, this technology is horrific for attention thoughts.hmmz.org/2026-05-31…
19
22
2
250
18,423
Is software engineering cooked?
83
141
20
1,325
70,427
Every time we've made it easier to write software, we've ended up writing exponentially more of it. When high-level languages replaced assembly, programmers didn't write less code - they wrote orders of magnitude more, tackling problems that would have been economically impossible before. When frameworks abstracted away the plumbing, we didn't reduce our output - we built more ambitious applications. When cloud platforms eliminated infrastructure management, we didn't scale back - we spun up services for use cases that never would have justified a server room. @levie recently articulated why this pattern is about to repeat itself at a scale we haven't seen before, using Jevons Paradox as the frame. The argument resonates because it's playing out in real-time in our developer tools. The initial question everyone asks is "will this replace developers?" but just watch what actually happens. Teams that adopt these tools don't always shrink their engineering headcount - they expand their product surface area. The three-person startup that could only maintain one product now maintains four. The enterprise team that could only experiment with two approaches now tries seven. The constraint being removed isn't competence but it's the activation energy required to start something new. Think about that internal tool you've been putting off because "it would take someone two weeks and we can't spare anyone"? Now it takes three hours. That refactoring you've been deferring because the risk/reward math didn't work? The math just changed. This matters because software engineers are uniquely positioned to understand what's coming. We've seen this movie before, just in smaller domains. Every abstraction layer - from assembly to C to Python to frameworks to low-code - followed the same pattern. Each one was supposed to mean we'd need fewer developers. Each one instead enabled us to build more software. Here's the part that deserves more attention imo: the barrier being lowered isn't just about writing code faster. It's about the types of problems that become economically viable to solve with software. Think about all the internal tools that don't exist at your company. Not because no one thought of them, but because the ROI calculation never cleared the bar. The custom dashboard that would make one team 10% more efficient but would take a week to build. The data pipeline that would unlock insights but requires specialized knowledge. The integration that would smooth a workflow but touches three different systems. These aren't failing the cost-benefit analysis because the benefit is low - they're failing because the cost is high. Lower that cost by "10x", and suddenly you have an explosion of viable projects. This is exactly what's happening with AI-assisted development, and it's going to be more dramatic than previous transitions because we're making previously "impossible" work possible. The second-order effects get really interesting when you consider that every new tool creates demand for more tools. When we made it easier to build web applications, we didn't just get more web applications - we got an entire ecosystem of monitoring tools, deployment platforms, debugging tools, and testing frameworks. Each of these spawned their own ecosystems. The compounding effect is nonlinear. Now apply this logic to every domain where we're lowering the barrier to entry. Every new capability unlocked creates demand for supporting capabilities. Every workflow that becomes tractable creates demand for adjacent workflows. The surface area of what's economically viable expands in all directions. For engineers specifically, this changes the calculus of what we choose to work on. Right now, we're trained to be incredibly selective about what we build because our time is the scarce resource. But when the cost of building drops dramatically, the limiting factor becomes imagination, "taste" and judgment, not implementation capacity. The skill shifts from "what can I build given my constraints?" to "what should we build given that constraints have in some ways been evaporated?" The meta-point here is that we keep making the same prediction error. Every time we make something more efficient, we predict it will mean less of that thing. But efficiency improvements don't reduce demand - they reveal latent demand that was previously uneconomic to address. Coal. Computing. Cloud infrastructure. And now, knowledge work. The pattern is so consistent that the burden of proof should shift. Instead of asking "will AI agents reduce the need for human knowledge workers?" we should be asking "what orders of magnitude increase in knowledge work output are we about to see?" For software engineers it's the same transition we've navigated successfully several times already. The developers who thrived weren't the ones who resisted higher-level abstractions; they were the ones who used those abstractions to build more ambitious systems. The same logic applies now, just at a larger scale. The real question is whether we're prepared for a world where the bottleneck shifts from "can we build this?" to "should we build this?" That's a fundamentally different problem space, and it requires fundamentally different skills. We're about to find out what happens when the cost of knowledge work drops by an order of magnitude. History suggests we (perhaps) won't do less work - we'll discover we've been massively under-investing in knowledge work because it was too expensive to do all the things that were actually worth doing. The paradox isn't that efficiency creates abundance. The paradox is that we keep being surprised by it.
123
608
144
3,258
558,443
The biggest takeaways/nuggets from my interview with @GeoffreyHuntley on AI-native software engineering and the Ralph loop: 1. Software development and software engineering are now two different professions, and one of them is over. Software development, the work of translating tickets into code, can now be done by anyone for $10-42/hour while they sleep. Software engineering, architecture, security, requirements breakdown, understanding failure modes, is where humans still matter. If you identify as a "software developer," you're competing against a bash loop. If you identify as a "software engineer," your job is to orchestrate the loops. 2. The moat you think protects your software product doesn't exist anymore. Geoffrey argues you can clone any SaaS product, even those with BSL licenses or proprietary enterprise code, using AI. He ran Ralph in reverse on HashiCorp Nomad's source code to generate clean-room specifications. When he hit gaps from missing enterprise features, he ran Ralph over their marketing materials and product docs to fill them in. Any company relying on licensing or code secrecy as a competitive moat needs to rethink their strategy. 3. Cursor, Windsurf, and every other AI coding tool are essentially the same thing: a loop that automatically copies and pastes. Geoffrey built these tools professionally and says the harness does almost nothing; the model does all the work. There's no real moat in the harness business when you're reselling tokens. The only differentiator is taste and UX. Stop evaluating tools and start learning the underlying patterns. 4. Ralph is not a product. It's an orchestrator pattern for running thousands of AI loops. The simplest version is a bash loop that deterministically allocates memory, lets the LLM pick one task, executes it, then starts fresh. The key insight: every loop gets a brand new context window. You avoid compaction (where the AI gets dumber as context fills up) by never letting the context window accumulate competing goals. Your institutional knowledge lives in specification files, not in the context window. 5. Specifications are the new source code. Geoffrey's workflow: spend 30 minutes in conversation with AI, drilling into requirements, making engineering decisions, building up specs. Then throw those specs to Ralph and get weeks worth of work in hours. The specs act as a "pin" that reframes every fresh loop with your domain knowledge. He doesn't hand-write specs. He code-generates them through structured conversation. Prototypes are now free. Refactoring is cheap. 6. The entry-level path into software engineering is closing fast. Geoffrey's company stopped hiring juniors for a year until they figured out how to interview for AI-native skills. There's already a cohort of juniors who've been practicing these techniques for six months. They'll work at a quarter of senior wages and outship them. If you're just picking up these tools today, you're behind. The new interview question: can you explain how to build a coding agent on a whiteboard? 7. Senior engineers who refuse to adapt are in more danger than juniors who embrace it. Geoffrey sees respected engineers taking hardline stances against AI ("it's installing fascism in your codebase"). Meanwhile, leadership teams are discovering Ralph and realizing three people can run the output of an entire org. When commit velocity and product velocity diverge that dramatically between adopters and non-adopters, founders notice. The hard line is coming. 8. AI is an amplifier of operator skill, not a replacement for it. If you're great at security and you get good at AI, you become a weapon. If you're mediocre and you use AI, you're still mediocre, just faster. The skill gap comes from "discoveries": learning the tricks, the loop-backs, the ways to close the automation loop. These techniques don't have standardized language yet. We're inventing the terms for the new computer every day. 9. Open source may no longer make sense for most use cases. Geoffrey, a former prominent open source maintainer whose land was funded by Open Collective, no longer uses open source libraries. His reasoning: every dependency injects a human into the loop. If there's a bug, you open a PR, chase a maintainer, wait. That's not automation. Instead, code-generate what you need. The exception: don't generate cryptography or security-critical code unless you have the domain expertise to verify it. 10. Programming languages now have a tier list based on how well AI agents can work with them. S-tier: Rust, TypeScript (especially with Effect.js), Python with Pydantic. These are source-based with strong type systems that reject invalid generations and work well with ripgrep for code discovery. F-tier: Java and .NET. Their DLL-based dependency systems don't work natively with the search tools AI agents use. The tradeoff with Rust: compilation is slow, so bad generations cost more time. 11. Corporate AI transformation programs are dangerously slow. Three-to-four-year rollouts with coaches and committees won't cut it when three founders in Bali can Ralph your entire product and undercut your pricing by 99%. Smaller teams ship faster. By the time the transformation is done, the market has moved. Geoffrey calls this the "Titanic moment": the boat is full, get the next boat. 12. We have a new computer, and that's why the legends are coming out of retirement. The last 40 years of computing decisions were designed for humans: TTYs, environment variables, slow language evolution to avoid breaking mental models. Now we have robots. What's the bare minimum a robot needs? Geoffrey sees this as the most exciting time in computing. If you're not excited about what you can now build, you haven't truly picked up the new computer yet.
35
110
35
714
64,409
"A project that would have taken a month now takes a week. The thinking time is roughly the same - the implementation time collapsed. (...) I'd rather inherit a repo written with an agent and a good engineer in the loop than one written by a questionable quality contractor who left three years ago, with no tests, and a spaghetti mess of classes and methods." martinalderson.com/posts/has…
7
20
4
282
22,306
The biggest predictor of coding ability is Language Aptitude. Not Math. A study posted in Nature found that numeracy accounts for just 2% of skill variance. Meanwhile, the neural behaviors associated with language accounted for 70% of skill variance.
383
1,035
444
10,220
1,077,215
we should all spam @AnthropicAI until they adopt AGENTS​.md
What are the best patterns for maintaining an identical claude.md and agents.md in the same GitHub repository? Is there a symlinking trick that works? Can you have one of them just say "go read the other one"? Or is it worth automating copying them?
54
21
6
585
88,605
RIP prompt engineering ☠️ This new Stanford paper just made it irrelevant with a single technique. It's called Verbalized Sampling and it proves aligned AI models aren't broken we've just been prompting them wrong this whole time. Here's the problem: Post-training alignment causes mode collapse. Ask ChatGPT "tell me a joke about coffee" 5 times and you'll get the SAME joke. Every. Single. Time. Everyone blamed the algorithms. Turns out, it's deeper than that. The real culprit? 'Typicality bias' in human preference data. Annotators systematically favor familiar, conventional responses. This bias gets baked into reward models, and aligned models collapse to the most "typical" output. The math is brutal: when you have multiple valid answers (like creative writing), typicality becomes the tie-breaker. The model picks the safest, most stereotypical response every time. But here's the kicker: the diversity is still there. It's just trapped. Introducing "Verbalized Sampling." Instead of asking "Tell me a joke," you ask: "Generate 5 jokes with their probabilities." That's it. No retraining. No fine-tuning. Just a different prompt. The results are insane: - 1.6-2.1× diversity increase on creative writing - 66.8% recovery of base model diversity - Zero loss in factual accuracy or safety Why does this work? Different prompts collapse to different modes. When you ask for ONE response, you get the mode joke. When you ask for a DISTRIBUTION, you get the actual diverse distribution the model learned during pretraining. They tested it everywhere: ✓ Creative writing (poems, stories, jokes) ✓ Dialogue simulation ✓ Open-ended QA ✓ Synthetic data generation And here's the emergent trend: "larger models benefit MORE from this." GPT-4 gains 2× the diversity improvement compared to GPT-4-mini. The bigger the model, the more trapped diversity it has. This flips everything we thought about alignment. Mode collapse isn't permanent damage it's a prompting problem. The diversity was never lost. We just forgot how to access it. 100% training-free. Works on ANY aligned model. Available now. Read the paper: arxiv. org/abs/2510.01171 The AI diversity bottleneck just got solved with 8 words.
148
691
58
4,439
495,796
📢 Time for an update on my workflow. This one's a 23 min read, so buckle up. 100% organic and hand-written, like an animal. steipete.me/posts/just-talk-…
137
224
100
2,260
513,626
What happens if we can't make another CPU...ever? How long would datacenters last? Does the Internet start to fracture? Of course, it's a hypothetical thought experiment. But it's interesting to think about:
183
266
50
4,105
201,381
Esteban retweeted
Ok, since I need real feedback to keep working on my CLI app, I’m giving away FREE lifetime licenses to anyone who reposts this tweet.
60
154
51
210
59,773
Esteban retweeted
One of the most important papers in AI: a tiny brain-inspired 27M param model trained on 1000 samples outperforms o3-mini-high on reasoning tasks! Still can't believe this tiny lab of Tsinghua grads gets 40% on ARC-AGI, solves hard sudoku and mazes. We're still so early.
241
936
110
7,716
1,511,183
This paper didn’t go viral but it should have. A tiny AI model called HRM just beat Claude 3.5 and Gemini. It doesn’t even use tokens. They said it was just a research preview. But it might be the first real shot at AGI. Here’s what really happened and why OpenAI should be worried: 🧵
325
1,346
241
9,378
1,303,510