{
  "video": {
    "id": "9fubhllmsBU",
    "title": "Field Guide to Fable — Thariq Shihipar, Anthropic",
    "duration": 1168,
    "upload_date": null,
    "channel": "AI Engineer",
    "source": "AI Engineer",
    "event_format": "In person"
  },
  "analysis": {
    "video_id": "9fubhllmsBU",
    "title": "Field Guide to Fable — Thariq Shihipar, Anthropic",
    "one_liner": "Anthropic's Thariq Shihipar gives a practical field guide to working with Fable: unhobble the model with tools and smaller prompts, then use the model itself to hunt down the unknowns in your own spec, because \"Fable's bottleneck is my ability to match the map and the territory.\"",
    "summary": "Shihipar argues that models are grown rather than designed, so what limits them is us — the harness and the prompt — and that each new model class opens a \"capability overhang\" we have to go discover. With Fable he says the constraint has moved from the model to the human: because it traverses so much ground, it hits decision points you never specified, so the job is finding your unknowns before and during the run. He closes with the emotional side (loving handwritten code but refusing to go back) and a call to stop being reasonable: tradeoffs that used to be forced are no longer real, and the way to prove agents work is to do the best work of your life faster.",
    "key_points": [
      "Capability overhang, illustrated with Pokémon: ask a chat model which of the ~1000 Pokémon end in \"AW\" and it fails; Claude Code fetches every Pokémon and writes a script to filter, returning Croconaw and Drednaw. Models get smarter in spiky ways — code execution beat recall and reasoning.",
      "The naive path to coding was a 100-million-token context window you paste your codebase into; the actual unlock was giving the model arms (the bash tool) so it builds and searches its own context — the insight that led to Claude Code. Claude Tag's unlock was working proactively and in multiplayer: Claude waking itself up to do work.",
      "They recently removed 80% of the Claude Code system prompt. Prompting best practice has inverted twice: Sonnet 3.5 new wanted a small prompt, few tools, many examples; then larger prompts, many examples, many tools; this new class wants a smaller prompt with fewer examples, because \"the examples tend to constrain it — it's actually more imaginative than the examples we give it.\" Give context, not constraints; avoid \"do not do this.\"",
      "The ask-a-question tool as a capability ruler: Opus 4 could barely call it and needed tool tweaking; by Opus 4.5 he could ask it to interview him with 40 questions about a spec; with Opus 4.8 and Fable it builds a whole HTML report with the questions embedded. Same progression for output: markdown → plan mode (readable by you) → in-depth HTML reports.",
      "\"The map is not the territory\": the plan/prompt/spec in your head is the map, the codebase is the territory, and every mismatch is an unknown — an unspecified decision point. He sorts them in a matrix: known knowns (what you write in the prompt), known unknowns, unknown knowns (too obvious to write down, but you know it when you see it), and unknown unknowns.",
      "Six concrete techniques: a blind spot pass (\"I'm working on a new auth provider I know nothing about — do a blind spot pass to help me figure out my relevant unknown unknowns and prompt better\", pointed at the module, git diff or Slack); brainstorm prototypes for unknown knowns (\"I have no visual taste — make me an HTML page with four widely different design decisions so I can react to them\"); asking Claude to interview you, with \"prioritize questions that would change the architecture\"; passing a reference artifact (code in another language, an HTML mockup for a React component) instead of writing a spec; asking it to log implementation notes whenever it hits an unknown so you can see where it deviated and why; and having it quiz you afterwards so you can actually represent the work at PR time.",
      "The grief: he ran a ~30-person YC startup where every roadmap was a forced tradeoff because code was hard; going back to that codebase recently, things that would have taken weeks took hours. He loved seeing a codebase in his mind and rotating it, but also remembers \"swimming in failure\" — most projects he worked on failed. \"The only way out is through.\"",
      "Being unreasonable: at Anthropic \"we believe that tradeoffs are not real\" — instead of prioritizing one thing per quarter, do all of it and force reality to show you the tradeoff. Good, fast, cheap is now pick three. He built the talk's deck the night before in about 4 hours with Fable.",
      "Framing for the audience: \"building is easier, but generating value is still hard\" — AI engineers over-focus on the process of building and their setups, when it takes a lot of swings to find the valuable thing. Treat the model as biology, not physics: empirical, organic, rules unknown but intuition buildable — he recommends Anthropic's \"Biology of a Large Language Model\" paper."
    ],
    "takeaways": [
      "Shrink your system prompts for this model class and strip the examples — they cap a model that is more imaginative than your examples. Supply context rather than \"do not\" constraints.",
      "Before prompting, run a blind spot pass to surface your unknown unknowns, and let the model interview you with architecture-changing questions; for taste-driven work ask for four deliberately different prototypes to react to instead of trying to describe what you want.",
      "Give Claude another map instead of writing a spec: reference code from another system or language, or an HTML mockup for the component you want.",
      "Instrument the run: have it log implementation notes at each unknown it hits, and have it quiz you afterwards so you stay in the loop and can defend the PR.",
      "Revisit the tradeoffs you're making implicitly — ambition, not prioritization, is now the bottleneck; try doing all of it and let reality show you where the real constraint is."
    ],
    "topics": [
      "agents",
      "coding-agents",
      "prompting",
      "context-engineering",
      "claude-code",
      "capability-overhang",
      "spec-writing",
      "developer-experience"
    ],
    "tools": [
      "Fable",
      "Claude Code",
      "Claude Tag",
      "Anthropic",
      "Claude Sonnet 3.5 (new)",
      "Claude Opus 4",
      "Claude Opus 4.5",
      "Claude Opus 4.8",
      "SWE-bench",
      "bash tool",
      "plan mode",
      "ask-a-question tool",
      "Slack",
      "Git",
      "React",
      "\"Biology of a Large Language Model\" (Anthropic paper)",
      "Y Combinator"
    ],
    "quotes": [
      {
        "text": "the models are grown, not designed",
        "at": "02:40",
        "url": "https://www.youtube.com/watch?v=9fubhllmsBU&t=160s"
      },
      {
        "text": "One of the best ways to give Claude a map is to give it another map",
        "at": "12:58",
        "url": "https://www.youtube.com/watch?v=9fubhllmsBU&t=778s"
      },
      {
        "text": "the only way to prove that agents work is to do the best work of our lives faster than ever before",
        "at": "17:42",
        "url": "https://www.youtube.com/watch?v=9fubhllmsBU&t=1062s"
      },
      {
        "text": "building is easier, but generating value is still hard",
        "at": "18:26",
        "url": "https://www.youtube.com/watch?v=9fubhllmsBU&t=1106s"
      }
    ],
    "words": 4055
  },
  "summary_url": "/#9fubhllmsBU",
  "transcript": {
    "html": "/transcripts/9fubhllmsBU.html",
    "txt": "/transcripts/9fubhllmsBU.txt",
    "vtt": "/transcripts/9fubhllmsBU.vtt"
  }
}