Thariq Shihipar left Anthropic this year. This 19-minute keynote from the AI Engineer CODE Summit is mostly about the predictions he got wrong. Each one was a version of the same fear: that the bitter lesson would hand us an alien intelligence with its own preferred way of doing things, and we’d have to work its way. His conclusion is the reverse. Once a task sits comfortably inside a model’s ability, the model will do it however you ask, so the bottleneck is deciding how you want to work. The second half shows what that looks like in a game he’s building.
The predictions that didn’t hold #

He starts with what he got right: models editing video, using HTML to understand their own work, helping people plan and learn. Then he moves to three wrong calls, which take up most of the first section.
The first was “Bash is all you need.” Claude Code was built around a Bash tool, and for a while the consensus was to turn everything into a CLI. That isn’t how it went. He now prefers MCP to CLIs, and code mode, skills and progressive disclosure all exist alongside them. Bash looked dominant only because of how the early models happened to be trained.
The second was “React is all you need.” Models were so good at React that it looked like it might be “the last language”. Now the same mockup comes out about the same in HTML, React, Swift, or Figma’s JSON format, and people are designing their own languages.
The third was “diffusion models will eat art.” He expected uncontrollable image models to take over. Instead, LLMs make art through code, through driving Blender or Photoshop, through Figma, which are all tools a human can control.
I think this is one of those things in AI where you sort of just like memory hole the things that you’re wrong about.
Industrial revolution and renaissance at once #

He argues software engineers are the leading edge for how AI will be used across knowledge work, so the habits they settle into will spread. He describes AI as two things happening together. One is industrialization: “software factories” that make shipping code reliable and cheap, which he says was the story of 2026. The other is a renaissance, where demand for quality rises and every extra bit of craft, utility or “soul” has economic value. He admits the two are hard to hold in your head at once.
The jagged frontier and the smooth interior #

Benchmarks track the jagged frontier, the hardest thing a model can do: write a function, then a feature, then a to-do app, then a Slack clone, then Mario Kart from scratch. Shihipar cares more about what he calls the smooth interior, the large area of tasks well inside that frontier. In that area capability isn’t jagged. If a model can write React it can also write Figma JSON or Swift, and it can do the task the way you prefer.

His example is an eval he credits to Karpathy. Ask a model “land or water?” at each of 16,200 points on a 2-degree grid, with no images or tools, and plot the answers. The slide shows Sonnet 4.5 at 60.5% and later models in the 90s, with Fable 5 at 97.8%. Older models give a blurry map and newer ones an almost exact one. He uses it to show breadth of knowledge rather than peak capability, and says breadth is what will define next year: “we can use intelligence to understand and shape how we use intelligence.”
When vibe coding stops being fun #
He’s building a 2D isometric fighting game inspired by Avatar and Smash Bros, and he describes the problem directly. When he asks for a character that throws a rock, the model has to make many small decisions. Does the rock go through the character’s own wall? How fast is it, how big, does it charge? The model decides all of these without him. When he plays the build, he doesn’t know what the character does. He gets distracted while prompts run and makes less progress than he expected.
He doesn’t accept that as the price of using agents. Good work, he says, comes from many deliberate choices about what goes in and what stays out, and you can’t make those choices about a system you don’t understand.
A folder written for the human #

His current fix splits the codebase in two. The engine (cameras, rendering, pixel pipeline) is agent territory, and he says outright that he doesn’t know how it works. A second folder, which he says he calls “spec” or “human”, holds the game logic in code that has to read almost like English. It’s linted, governed by explicit CLAUDE.md rules, and uses real units like seconds(0.6) and meters instead of magic numbers. Each character’s moves, for example the three ways one character can throw a rock, are defined in this layer.
In the demo he opens rock.ts, changes the rock’s size to 1.5, and plays the result. He also says he’s using Cursor’s tab completion more, because he edits this layer by hand now. Claude still builds new primitives when he needs one, but he can review that work while it runs.
It’s kind of like spec driven development, you know, but the spec is this like this this scripting language basically.
He doesn’t claim this is the final answer. He says he’s still early with it.
What a renaissance could bring #

His last slide lists open areas: languages that are fast but also modular and hot-reloadable, new database and server primitives, personal software that changes how your operating system behaves, a second look at old HCI research, and new aesthetics. His closing request is that engineers decide what they want work to look like, since the models aren’t forcing any particular shape on it.
Key takeaways #
- Shihipar’s wrong predictions (Bash everywhere, React as the last language, diffusion eating art) all assumed that a model’s training-time preferences would set how we work. They didn’t.
- Benchmarks measure the jagged frontier, but the more useful property for building software is the smooth interior: when a task is well within capability, the model can do it in whatever form, language or tool you choose.
- Pure vibe coding has a cost for creative work. The model makes design decisions you never see, so you can’t tell what you built or tune it.
- His workaround is to split the codebase into agent-owned engine code and a human-owned layer written as a readable, linted scripting DSL with real units, which works as an executable spec.
- With that split he’s back to hand-editing and using tab completion for the parts he cares about, and he can review Claude’s primitive-building work as it happens.
- He frames 2026 as the year software was industrialized, and argues the next step is a renaissance in quality, which depends on engineers deciding how they want to work.
Source #
- Talk: “The Sweet Side of the Bitter Lesson”
- Speaker: Thariq Shihipar (independent, formerly Anthropic)
- Event: AI Engineer CODE Summit 2026 (keynote)
- Duration: 19:08
- Video: https://www.youtube.com/watch?v=xRJMiaUoD_8