Tyler Fox @smileyborg

1. as a mental model it is more correct to think of fable+ class models as english -> code interpreters - converts your idea into code into "correct" code regardless of problem complexity and output complexity (diff size). Fable 5 will be the worst of this new class of models 2. diff size/complexity is to be managed purely for review: small diffs - in high risk areas of code (auth/identity/data access/network access/money movement) large diffs for code that can be empirically verified (frontend/backend plumbing/code without network or db access/performance code that can be empirically verified) 3. time it takes to ship software is completely disconnected from time to produce the PR - how long the work takes depends fully on ability to review/merge code while managing risk at scale 4. solving the bottlenecks for above matter enormously- linters/testing/CI/shadow mode verification/empirical verification 5. agency matters enormously- what are the biggest bottlenecks to speeding up the loop and eliminating them? what are the problems that need solving and when do they need solving? what does it take to the solution to all of them today? 6. deep understanding of the full stack matters enormously- what problems are worth pursuing? is there a higher level of problem abstraction to address first? should I give it the sub-sub task, the sub task, or the task itself. what are the major risks with this PR (order of importance: security holes/correctness holes/performance holes). is there a higher speed way of producing data that allows me to merge this? should this be run in shadow or in a sandbox or a flag. understanding every line of logic may not be needed but understanding and managing risk matters enormously. 7. the cost of complexity itself is changing. it might be now worth "maintaining" 50% more code to get a 5% performance win. getting the right abstractions matter less because larger refactors are less tedious. code quality nits become huge drag. very likely, a much smarter model will be maintaining your code so worth taking on more technical debt now. taking the time to hand architect and rebuild systems comes with an enormous cost of velocity 8. if it quacks like a duck and walks like a duck, it's a duck. For low risk cases, it might be more sane to treat code chunks (services / functions) as a black box, like we do for neural networks: do full empirical verification only: has code produced correct outputs for the last 10,100,1000,10k inputs ? can we quarantine this large piece of code - no outbound access to network / database ? what happens when this code is wrong? do we get hacked/or crash(memory/cpu)/is an inconvenience? is it internal facing or external? what can we do to address these risks? 9. eventually, logical verification (line by line review) will come at an enormous cost- save it for where it matters and build systems that are tolerant to empirical verification. is there a decorator that prevents db / network access? correctness bugs are significantly easier to rectify than access bugs 10. what are the rails that allow for even faster iteration? code permissions can be opt in - db writes, db reads, network egress (to where?), PII access. how long does it take to get shadow mode data? how many PRs can be tested? What are the categories of diffs

@doodlestein The worst thing about Fable is how it’s going to make Opus hard to go back to

2026: coding agents can one-shot a function to invert a binary tree in any programming language known to humankind also 2026: god forbid the agent inserted new section 3 and now has to renumber all 12 sections below it in a markdown document

@lossybrain 🎯

While it may be true today, this opinion is not going to age well. LLMs don’t need to be deterministic to produce consistent and reliable results, especially at the level of the individual tasks they will be expected to perform relative to their intelligence capability.

Ben Dickson @bendee983

2 months ago

Compilers are deterministic. Give them the same code with the same compiler settings, and you'll always receive the same binary. You can take responsibility for your software at the code level. LLMs, on the other hand, are stochastic. Even if you set the temperature to zero,

114 203 3K 214K 395

Code review today is often also intent, architecture, and approach review. Those aspects will surely remain. But I am confident that we can and will move on to better ways to increase confidence in the correctness of the code, without relying on humans to read and review it all.

Note that this doesn’t mean that all software engineers will just be vibe coding. The distinction between that and agentic engineering is stark: the latter implies high standards for architecture, quality, & correctness. Code still matters, but it’s mostly implementation detail.

Jeffrey is doing incredible open source work with agents — dcg is probably the most important project that you should be using with Claude Code or Codex

Jeffrey Emanuel @doodlestein

2 months ago

It's now been around 4 months since my open-source dcg tool was first released, and I know from hearing from tons of users that it has saved countless people from disaster at the hands of overeager Claude Code agents. I've continued to make various performance improvements and

keyboard_arrow_left Previous keyboard_arrow_right Next

15 9 93 14K 92

NYC is a fantastic city, it’s a shame nothing like it exists in CA

Can’t wait to see their SOLE.md

Tracy Alloway @tracyalloway

2 months ago

Allbirds, the shoe brand, now says it's an AI compute company.

367 674 10K 4.3M 1K

I love Karpathy's posts because they're so on point. He's not only a leading expert in his field, but he also manages to capture the zeitgeist with his statements. But this post is particularly impactful. Since December, (agentic) coding has undergone a significant transformation, one could even say a qualitative leap. Before, it was a matter of iterative improvements, but since the end of last year, it has demonstrated its true value in a completely different way. Or, in Karpathy's words: "It is hard to communicate how much programming has changed due to AI in the last 2 months: not gradually and over time in the "progress as usual" way, but specifically this last December. There are a number of asterisks but imo coding agents basically didn’t work before December and basically work since. (...) As a result, programming is becoming unrecognizable. You’re not typing computer code into an editor like the way things were since computers were invented, that era is over. You're spinning up AI agents, giving them tasks *in English* and managing and reviewing their work in parallel." Two points on this that need to be repeated again and again because they are often still misunderstood. 1) The very basic truth: this is the worst it will ever be. From here on out, things will get better. Even if the status quo were to remain as it is, it would be serious. But what we have today is the worst it will ever be. 2) The pace of progress is constantly increasing. It is exponential. And that's the crucial point: from December to February, more happened than in a very long time. And this trajectory will likely (almost certainly) continue. If points 1) and 2) are true, it is simply impossible to foresee and predict how this will affect society and all essential areas. As much as I welcome and approve of this, the near future is unpredictable. That's all I wanted to say.

Andrej Karpathy @karpathy

4 months ago

It is hard to communicate how much programming has changed due to AI in the last 2 months: not gradually and over time in the "progress as usual" way, but specifically this last December. There are a number of asterisks but imo coding agents basically didn’t work before December

2K 5K 37K 5.1M 20K

We’re gonna reach AGI before Tesla solves auto windshield wipers, aren’t we

Software engineering in 2026

There’s nothing like being a software engineer today, using frontier models and agents firsthand, to see how the world is being revolutionized in real-time.

Shell shocked seeing this in the Epstein files 🫨 justice.gov/epstein/files/…

It's only been one year since vibe coding was coined...

Andrej Karpathy @karpathy

a year ago

There's a new kind of coding I call "vibe coding", where you fully give in to the vibes, embrace exponentials, and forget that the code even exists. It's possible because the LLMs (e.g. Cursor Composer w Sonnet) are getting too good. Also I just talk to Composer with SuperWhisper

1K 4K 34K 7.2M 18K

Even if current LLM progress hits a brick wall at Opus 4.5 level (and I doubt that will happen) the next 12 months are still going to be a staggering time of change in this industry as decision makers start truly understanding the new reality we live in. obie.medium.com/what-happens-w…