Field Guide to Fable — Thariq Shihipar, Anthropic

Thariq Shihipar, from Anthropic’s Claude Code team, introduces Fable, the company’s newest and most capable model, likening its release to “the map opening up” in an RPG—a vast, exciting, yet initially intimidating new landscape for AI development. He presents a “field guide to Fable” structured around four key principles: Unhobbling Claude, Finding Your Unknowns, Dealing with the Grief, and Being Unreasonable.

Unhobbling Claude

Shihipar emphasizes that models are “grown, not designed,” meaning their capabilities are organic and discovered through interaction, not strictly engineered. The limitations of LLMs often stem from our understanding and prompting methods, not the model’s inherent capacity. He introduces the concept of “capability overhang,” where models get smarter in “spiky ways.” He illustrates this with the example of Pokémon names ending in “AW”: a standard chat model fails, but Claude Code, given access to tools, can write a script, fetch a list, and filter it to find the answer. This highlights that tool use, rather than just raw reasoning, unlocks significant capabilities.

He traces the evolution of models and tools:

• Context Management: Early models relied on large context windows. Claude Code pioneered using tools like Bash to build and search its own context, a “spiky innovation.”
• Agentic Behavior: Claude Tag further evolved this, demonstrating proactive, “multiplayer” capabilities, able to “wake itself up” to perform tasks, a key step towards advanced agents.
• Prompting Paradigm Shift:
  • Older models (e.g., Sonnet 3.5 new): Best practices involved small system prompts, few tools, and many examples.
  • Smarter models: Allowed larger system prompts, many examples, and more tools.
  • Fable/New class: Requires smaller system prompts because examples tend to constrain its imagination. The focus shifts from strict constraints (“Do not do this”) to providing context.
• Tool Advancements:
  • “Ask User Question” tool: Evolved from barely functional in Opus 4 to enabling detailed “interviews” in Opus 4.5, and now, with Fable, generating embedded HTML questionnaires.
  • Markdown/HTML output: Progressed from simple formatting to dynamic, in-depth HTML reports that facilitate deeper interaction.

Shihipar concludes this section by likening model development to biology rather than physics—an empirical, organic process where intuition must be built alongside scientific understanding. He recommends Anthropic’s paper, “The Biology of a Large Language Model.”

Finding Your Unknowns

This section focuses on “unhobbling yourself” by aligning your mental “map” (plan, prompt, spec) with the “territory” (codebase, real-world constraints). An “unknown” is defined as a decision point Claude encounters that wasn’t specified in your map. Fable’s advanced capabilities mean it will traverse vast areas and inevitably hit many unknowns.

To find and manage these unknowns, Shihipar suggests several strategies using Fable:

• Blind Spot Pass: Ask Fable to review a topic (e.g., an unfamiliar auth provider in a codebase) and identify relevant “unknown unknowns” or potential pitfalls to refine your prompting. This can also apply to learning new fields (e.g., color grading).
• Brainstorms & Prototypes: Address “unknown knowns” (things you “know when you see it,” like design preferences) by asking Fable to generate diverse options (e.g., four different HTML design decisions) for you to react to.
• Interviews: Have Fable interview you about your project, using additional context, to uncover unconsidered aspects or areas needing further specification.
• References: Provide Fable with existing code, designs (e.g., an HTML mock-up for a React component), or system examples as a “map” to guide its work, even if in a different language or system.
• Implementation Notes: Instruct Fable to log any “unknowns” it encounters during execution, providing insights into deviations and underlying reasons.
• Quizzes: Ask Fable to quiz you on its completed work to ensure you understand the implementation details and stay in the loop.

Dealing with the Grief

Shihipar reflects on the profound shift brought by LLMs, experiencing both “a huge sense of gain” and “a sense of loss.” He recalls the “foreign country” of pre-LLM coding, characterized by constant, difficult tradeoffs (e.g., fast app vs. new features taking months) and “swimming in failure” through countless failed projects and debugging struggles. While he loved programming, he asserts, “I cannot go back.” The message is that “the only way out is through”—embracing the new paradigm, staying engaged, and continuing to learn.

Being Unreasonable

The final principle challenges conventional notions of tradeoffs. Shihipar highlights Anthropic’s culture, which questions if tradeoffs are “real,” advocating for asking, “What if you just did all of it?” He argues that the capabilities of Fable change the “math” of such decisions, urging developers to demand all three from “good, fast, cheap,” instead of picking two. He provides a personal example of building his entire keynote deck in four hours with Fable. He emphasizes that AI engineers are tasked with proving that AI delivers productivity and saves time, advocating for ambitious work that is faster and better than ever before. While building with AI is easier, generating value remains a difficult but crucial goal, requiring many iterations. His call to action is to “go explore, make it real, and…be less reasonable.”

• Tags:
• Software Development
• Agentic AI
• Prompt Engineering
• LLMs
• Feature
• Anthropic
• Claude Code
• AI Engineering
• Tool Use
• Human-AI Collaboration
• Fable
• Capability Overhang