Bitter Lesson's Sweet Side: Keep Control of AI Code (Thariq Shihipar)
Thariq Shihipar revisits Rich Sutton's Bitter Lesson and argues coding agents can keep developers in creative control. Vibe coding a fighting game left him lost, and a readable spec folder gave him back control. In this episode: - The jagged frontier and the smooth interior - Vibe coding versus code you can explain - Readable specs next to the engine code Sources: Thariq Shihipar; Rich Sutton; Ethan Mollick; Simon Willison; Erin Yepis; Birgitta Böckeler; Rodney Brooks Big AI ideas, made clear for builders. luongnv.com/podcast
Listen on Build Wiz AI Show Download MP3 Transcript
Based on The Sweet Side of the Bitter Lesson by Thariq Shihipar
Transcript
Alice: What happens when a developer vibe codes his own fighting game, and ends up with no idea what his characters actually do?
Bob: He found a fix that keeps the AI and gives him back control. And it starts with an old essay, "The Bitter Lesson".
Alice: Welcome to Build Wiz AI Show. Big AI ideas, made clear for builders. I'm Alice, and today I'm the one asking the questions.
Bob: And I'm Bob! Today we're unpacking Thariq Shihipar's talk, "The Sweet Side of the Bitter Lesson", on the AI Engineer channel, from CODE Summit 2026.
Alice: Bitter and sweet. It already sounds like dessert.
Bob: A little! He opens with what he's been thinking about since he left Anthropic: what he got right this year, and the ways he's been wrong. Six outside sources and three guests will help us test it.
Alice: Start with the title. What is the Bitter Lesson?
Bob: It's a short essay by Rich Sutton. His claim: the biggest lesson from 70 years of AI research is that general methods that leverage computation are ultimately the most effective, and by a large margin.
Alice: Computation meaning, just more computer?
Bob: Pretty much. In chess, the methods that beat world champion Kasparov in 1997 were based on massive, deep search. Go, speech recognition and computer vision went the same way.
Alice: So why is it bitter?
Bob: Because researchers kept building in how they think the mind works. Sutton says that always helps in the short term, but in the long run it plateaus, and the breakthrough comes from scaling search and learning instead.
Alice: Give me a picture.
Bob: Picture two cooking students. One memorizes grandma's recipe cards, the other just cooks and tastes, over and over. The first looks great early; the second wins in the end, and the recipe cards are the human knowledge researchers build in.
Alice: Okay. So where does Thariq come in?
Bob: He lists fears he had. First, Bash is all you need: agents were great at the shell, and Claude Code was built around the Bash tool. Now he prefers MCP, and calls Bash a weird remnant of how the models were trained at the start.
Alice: Let me guess. React was next.
Bob: React is all you need! Models looked great at React, so he feared we'd be writing React forever. Now they write HTML, React, Swift, even Figma's own JSON format, and it all looks roughly the same.
Alice: React forever. That's a horror movie for some developers.
Bob: And the third fear: diffusion models would eat art, and we'd have no control over them. Instead, he says, models now make art through code, and by driving tools like Blender, Photoshop or Figma.
Alice: So what's the sweet side?
Bob: We don't have to submit to a foreign intelligence. Think of a session musician who plays any style you hire them for, instead of a jukebox stuck on one song: you still pick the song. His question becomes how to be AGI-pilled and human-centered at once.
Alice: He says this matters beyond software. Why?
Bob: He calls software engineers the leading edge of AI adoption: whatever happens to software will happen to knowledge work and other parts of the economy. So how we work with AI is how others will, too.
Alice: No pressure, then.
Bob: Here's his big frame: AI is an industrial revolution and a renaissance at the same time. This year was the industrial revolution: software factories, turning an unreliable craft that was hard to execute on into something that's not the limiting factor.
Alice: And the renaissance part?
Bob: People want higher and higher quality software, and every bit of creativity, spirit and soul you put in is economically valuable. Imagine a bakery: the factory line turns out identical loaves, while the master baker makes the loaf people cross town for. And Ethan Mollick's study found AI outputs a bit homogenous and same-y, so the human touch is the scarce part.
Alice: Now, the jagged frontier. I've heard the phrase, but never really got it.
Bob: It comes from Ethan Mollick's post "Centaurs and Cyborgs on the Jagged Frontier", on One Useful Thing. On some tasks AI is immensely powerful, on others it fails completely or subtly, and unless you use AI a lot, you won't know which is which.
Alice: Example?
Bob: A sonnet is easy for AI, but a poem of exactly 50 words is hard. In his study with Boston Consulting Group, consultants using AI on tasks inside the frontier finished 12.2 percent more tasks, 25.1 percent faster, with 40 percent higher quality.
Alice: And outside the frontier?
Bob: On a task built so the AI gives a wrong but convincing answer, consultants got it right 84 percent of the time without AI. With it, only 60 to 70 percent. Mollick says they fell asleep at the wheel.
Alice: Ouch. So where does Thariq's smooth interior fit?
Bob: Mollick watches the edge, but below the frontier, Thariq says, it's not jagged: if a model can write React, it can write Figma, it can write JSON. Picture a coastline: the edge is all cliffs and inlets, but the bay inside is calm. That calm bay is the breadth of tasks models are really, really good at.
Alice: Why care more about the bay than the cliffs?
Bob: He doesn't really care that they can build Mario Kart from scratch anymore. He cares whether the software we build is high quality, worthy of a renaissance.
Alice: Mario Kart from scratch is the boring part now. What a time.
Bob: He goes further: the perfect model won't need to verify its work or scan for security vulnerabilities. To show what models know, he asks one whether points on Earth are land or water, and plots the map. An older Opus model draws it blurry; a newer one, almost perfect.
Alice: So, back to the fighting game from the start.
Bob: He's building a 2D isometric fighting game, inspired by Avatar and Smash Brothers, trying to be a great vibe coder. He'll say: I want this character to throw a rock. Then come the questions: does the rock go through the wall the character can summon, and what about size and charge?
Alice: And the model just answers all of that for him?
Bob: Exactly. It makes a bunch of choices, he tries it out, and thinks: I have no idea what this character actually does. He sends off a prompt, does something else, and honestly makes less progress.
Alice: That sounds familiar. But isn't that just what vibe coding is?
Bob: Pretty much by definition. Simon Willison, on his weblog, defines vibe coding as building software with an LLM without reviewing the code it writes. The term was coined by Andrej Karpathy, for coding where you forget that the code even exists.
Alice: Is Willison against it?
Bob: No, for low stakes projects and prototypes he says, why not let it rip? But for production, he won't commit code he couldn't explain to somebody else. It's like hiring a builder to redo your house while you're away: you come back to rooms you never chose, and no idea which walls hold up the roof.
Alice: So he lost the plot of his own game. Did he just accept that?
Bob: For a while, he thought that's just how you work with AI. Then he decided it's not acceptable: to make something great, you have to really know your stuff. Willison says the same about the job itself: code that demonstrably works and can be understood by other humans.
Alice: Do other developers feel this? Maya, you went through the numbers.
Maya: Erin Yepis wrote up Stack Overflow's Developer Survey on the Stack Overflow blog, with more than 49,000 developers. 80 percent now use AI tools in their workflows, but trust in the accuracy of AI fell from 40 percent to just 29 percent.
Alice: Just 29 percent! So what's bugging them?
Maya: The top frustration, cited by 45 percent, is AI solutions that are "almost right, but not quite". And 66 percent say they spend more time fixing almost-right AI code. Also, nearly 72 percent said vibe coding isn't part of their professional work.
Alice: So how is Thariq fixing it?
Bob: He's careful to say he's still early and hasn't figured it all out. But he split his codebase in two: an engine part, and a folder he calls spec, or maybe just human. That folder is the code he reads.
Alice: What makes it readable?
Bob: It's linted, there are rules for Claude about how that code looks, and it's supposed to feel like English. Think of a board game: the rulebook is what players read and change, and the factory that prints the pieces stays out of sight. The spec folder is the rulebook; the engine is the factory.
Alice: Walk me through the demo.
Bob: There's agent code he doesn't understand, cameras and so on. But in the spec code he sees all his characters and their abilities, like the rock move: well commented, using meters. He can see there are three ways for that character to throw a rock.
Alice: So he basically wrote his own language?
Bob: In his words, almost a custom scripting language for his game. He wants a bigger rock, so he types 1.5 in a real code editor, plays, and the rock charges, gets really big, and flies.
Alice: Change one number, and a giant rock flies. That's the dream.
Bob: And he's using Cursor's tab completion more: he writes, if you summon a wall in the middle, queue it up as an action, and the editor completes it. He calls it kind of like spec-driven development, where the spec is the scripting language.
Alice: Spec-driven development is a buzzword now. Lena, you dug into it.
Lena: Birgitta Böckeler, writing on Martin Fowler's site, says the definition is still in flux. Her best reading: you write a spec before writing code with AI, and the spec becomes the source of truth for the human and the AI.
Alice: One kind of spec, or several?
Lena: She sees three levels: spec-first, where you write it and use it for the task; spec-anchored, where you keep it to evolve the feature later. And spec-as-source, where only the spec is edited by the human, who never touches the code.
Alice: And Thariq still asks Claude for the hard parts?
Bob: Yes. For something complicated he still asks Claude to make the primitives, but it's easy to understand what's happening. He feels much more in control, and he can review while Claude works.
Alice: So what's his big takeaway?
Bob: He now thinks about the best way to deliver high quality software, not about what the model likes to write code in. Internalize that, he says, and next year will be about a renaissance of software.
Alice: What does that renaissance need?
Bob: His list: new languages, efficient like Rust, but also modular, hot-reloadable and readable. New primitives, maybe new databases, servers and operating system interactions. New interaction paradigms, where old HCI research is worth revisiting, and new aesthetics.
Alice: And how does he close?
Bob: We need to decide what the future of work looks like, because the models aren't an alien intelligence forcing one way of working. It's like a new paint set with every color: the paint never chooses the painting. Mollick ends his post on the same note: we get to make choices about how we want to use AI.
Alice: So the job is ours.
Bob: His last words, basically: our job is to bring about the renaissance.
Alice: Time for Counterpoints. Sam, you brought a critic of Sutton himself.
Sam: Rodney Brooks answered Sutton on his own site, in "A Better Lesson". He points to the networks that label images, CNNs: their front end is designed by humans to handle the idea that objects can appear anywhere in the frame.
Alice: So the human knowledge never really left?
Sam: That's his argument. He calls it sleight of hand: humans still pour their intelligence into the algorithms, just in a different place and form. His better lesson is to count the total cost of any solution, and so far they have all required substantial amounts of human ingenuity.
Alice: Which sounds close to Thariq, honestly. The human part moves, it doesn't vanish.
Bob: That's my take too, but Brooks wrote it as a direct critique: he thinks Sutton is wrong. And Sutton's essay holds the opposite view: building in our discoveries only makes it harder to see how discovering can be done.
Alice: Lena, does writing specs really keep you in control?
Lena: Böckeler has doubts. When she asked one tool to fix a small bug, it turned it into 4 user stories with 16 acceptance criteria, like using a sledgehammer to crack a nut. And she'd rather review code than all those markdown files.
Alice: So a spec can turn into a mountain of paperwork.
Lena: And a false sense of control: she frequently saw the agent not follow all the instructions anyway. She also recalls model-driven development, which never took off for business applications, and asks if we're making something worse while trying to make it better.
Alice: Maya, what about the smooth interior? A model so good we stop checking?
Maya: The survey points the other way, for now. When the code gets complicated and the stakes are high, developers turn to people: 75 percent said they'd still ask another person for help when they don't trust AI's answers.
Alice: And that's before the model is perfect.
Bob: Right. Mollick warns that people really can go on autopilot with AI and fail to notice its mistakes. And Thariq's fix is one game, one demo, still early, so it's a direction, not a proven method.
Alice: Builder's Corner! What can listeners try this week?
Bob: Pick one feature, say one character or one settings screen, and keep a readable spec file for it next to the engine code. Write it the way Thariq does, in plain words and real units like meters, so when you read it, you know what's happening and can tweak it.
Alice: And where does the agent come in?
Bob: Ask the agent to edit the spec first, and only then the engine. Give it rules for how that file should look, like Thariq's rules for Claude, and use Willison's test: if you couldn't explain a change to somebody else, don't commit it.
Alice: Keep it small?
Bob: Very small. One feature, not a giant document, so you can tell after a week whether you really feel more in control.
Alice: Takeaways. Mine: compute wins, as Sutton says, but the sweet side is that models can work the way we want.
Bob: Mine: the jagged frontier gets the headlines, but the smooth interior is where your daily work lives.
Alice: Vibe coding is fine for low stakes projects. But if you can't explain it, don't ship it.
Bob: And split what you read from what the agent runs: a readable spec, next to the engine.
Alice: What's still open?
Bob: Whether the perfect model that needs no checking ever arrives, while trust in AI's accuracy is falling. And whether readable specs scale beyond one person's game: Thariq himself isn't sure it's the final way he'll write it.
Alice: And who leads that renaissance: builders, or the models?
Bob: Thariq's answer is us. Whether we take the job is the open part.
Alice: Big job. Count me in.
Bob: Thanks to Thariq Shihipar for his talk, "The Sweet Side of the Bitter Lesson", on the AI Engineer channel. Thanks also to Rich Sutton's "The Bitter Lesson", Ethan Mollick on One Useful Thing and Simon Willison's weblog. And to Erin Yepis on the Stack Overflow blog, Rodney Brooks's "A Better Lesson", and Birgitta Böckeler on Martin Fowler's site.
Alice: That was the sweet side of the Bitter Lesson. That's all for today on Build Wiz AI Show. Thanks for listening, and see you next time.