Every developer using AI for coding has hit the same wall. You spend twenty minutes crafting a meticulously detailed prompt, providing every piece of context you can think of, only for the AI to return a solution that is technically functional but conceptually wrong. It misses a critical edge case, ignores a systemic constraint, or implements a feature in a way that contradicts the existing architecture. The frustration stems from a recurring realization: the more we rely on the model's raw reasoning power to fill in the blanks, the more likely the AI is to wander off in a direction we never intended.
The Architecture of Agentic Implementation
Fable emerges as a methodology to bridge this specific divide, utilizing Claude Code—Anthropic's terminal-based AI coding tool—to move beyond simple prompt-and-response cycles. The practical application of this approach was demonstrated in the production of Fable's own launch video. The entire editing process was handled through Claude Code, leveraging Remotion, a React-based framework for creating videos programmatically. By feeding the AI existing company data and the Remotion framework's constraints, the team could prototype and validate visual elements in real-time.
One of the most significant hurdles in this project was color grading, a domain where the developers lacked deep professional expertise. Rather than attempting to describe the desired aesthetic in vague adjectives, they treated this technical gap as a specific unknown to be solved. They tasked the AI with learning the domain and applying the necessary technical corrections, effectively using the agent to fill a professional knowledge void through iterative interaction.
To maintain control over these variables, Fable introduces a rigorous documentation and verification loop. Instead of relying on the AI's short-term memory or the user's ability to remember every instruction, the team utilizes a specific file named `implementation-notes.md`. This file serves as a living record of edge cases, architectural decisions, and constraints that the model must adhere to. By explicitly training the model on this file, the developers ensure that the AI's context is anchored in documented reality rather than probabilistic guessing.
Verification does not end with a successful build. Fable implements a strict merge criterion: the AI must pass a quiz. After completing a task, the developer asks Claude to generate a quiz based on the changes it just made. Only when the AI can perfectly explain the logic and the reasoning behind the implementation is the code merged into the main branch. This transforms the merge process from a hopeful review into a verified transfer of knowledge.
The Shift from Model Power to Unknown Definition
The core insight of Fable is that the failure of agentic coding is rarely a failure of the model's intelligence, but rather a failure of definition. Fable conceptualizes this as the gap between the map and the territory. The map consists of everything the user provides: the prompts, the available skills, and the provided context. The territory is the actual codebase, the physical environment, and the hard system constraints. When an AI produces an incorrect result, it is because the map is an inaccurate representation of the territory.
To navigate this, Fable categorizes the gaps into four distinct types of unknowns. Known Knowns are the explicit requirements written directly into the prompt. Known Unknowns are the gaps the developer is aware of but lacks the specific information to fill. Unknown Knowns are the implicit truths—things so obvious to a human developer that they are left out of the prompt, but which the model can identify immediately upon reading the code. Finally, Unknown Unknowns are the blind spots: the requirements the developer never considered and the constraints they didn't know existed.
To tackle these blind spots, Fable employs a technique called the blindspot pass. This is not a standard prompt but a strategic interrogation of the model. First, the user provides deep context about their own identity and current knowledge level. Then, the user explicitly asks Claude to perform a blindspot pass or identify the unknown unknowns. By forcing the model to look for what is missing rather than what is present, the developer can identify requirement gaps before a single line of code is written.
This approach shifts the primary lever of quality from the model's benchmark score to the user's ability to define the unknown. In this framework, source code becomes the ultimate reference. While diagrams, documentation, and screenshots provide a general idea, they are low-fidelity maps. By pointing Claude toward specific library folders or design component directories, the AI can analyze the actual markup and structural implementation. This direct analysis of the territory eliminates the ambiguity of text-based descriptions and provides a high-fidelity foundation for the agent to work from.
Agentic coding is no longer a contest of which model has the largest parameter count, but a discipline of how precisely a human can map the unknown.
