The argument in one line.
A structured seven-step skill that keeps every design decision inside Anthropic's models and delegates only mechanical execution to cheaper tools turns a single prompt into an animated, client-ready website for about $10.
Read if. Skip if.
- You use Claude Code (or want to) and want a repeatable system for generating polished, animated marketing sites instead of hand-coding or paying a designer.
- You're burning AI credits fast on design work and want a cost-control pattern that doesn't sacrifice output quality.
- You sell websites or landing pages to clients and want a faster, cheaper production pipeline.
- You're curious how to chain multiple AI models (Claude, GPT, Higgsfield) into one build process without losing design coherence.
- You need pixel-perfect, hand-editable control over layout and code — this is a one-shot generative workflow, not a design system you tweak line by line.
- You don't have a Higgsfield or ChatGPT subscription and aren't willing to add either — the pipeline depends on both.
- You're looking for a coding walkthrough — this is a prompting/orchestration workflow, not an explanation of the generated code.
The full version, fast.
Jack Roberts open-sources a Claude Code skill that turns a single prompt into an animated, agency-grade product website for about $10. The system enforces a strict division of labor: Anthropic's Fable 5 and Opus own every design decision — art direction, brand, layout, the shot list, the code — while cheaper rented models (Higgsfield for motion, GPT-5.6 for scaffolding and checks) only execute, never decide. Before any expensive render happens, one Anthropic model proposes the concept and another critiques it, catching weak ideas for free. The build runs seven steps — spec, direct, render, gate, build, review, verify — ending in a printed cost receipt. The lesson generalizes past web design: keep judgment calls on the expensive model, push repetitive execution onto the cheap ones.
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.

01 · Intro
Cold open states the promise directly: Fable 5 builds websites that sell for thousands, and this video shows the exact system.

02 · What Fable 5 actually produces
Montage of prior Fable 5 sites — scroll-driven reveals, a descent-into-mountain narrative, filling animations — all built in one shot.

03 · Why the driver matters as much as the model
The 'best driver, fastest car' framing: a skilled operator with a weaker model beats a top model with weak prompting.

04 · Grabbing the free skill
Downloads the Fable 5 Website Skill from his community classroom and drops it into Claude Code.

05 · Full mode vs cost saving mode
The skill asks whether to run no-holds-barred on the best models throughout, or a cost-saving mode that mixes in cheaper models.

06 · Connecting Higgsfield to Claude
Authorizes Higgsfield via CLI so Claude Code can call its image/video generation models directly.

07 · Answering the setup questions
Walks through the skill's intake questions: site type, single most important visitor action, brand direction, logos/fonts.

08 · Building three websites simultaneously
Describes a fruit smoothie brand in one prompt; the skill returns three distinct design directions and builds all three at once.

09 · Website showcase and results
Tours the finished sites — Pulp (fruit brand), Nocturne (perfume), Alpenglow (alpine retreat) — plus a confession about overspending Anthropic credits before landing on the cost system.

10 · The model split system explained
Names the 'two lanes never cross' rule and the seven-step pipeline (spec, direct, render, gate, build, review, verify) that keeps Anthropic owning every decision.

11 · What it actually costs per site
Breaks down the roughly $10 total cost — almost all of it video generation — and closes with a pitch to a follow-up video on hosting and client handoff.
Lines worth screenshotting.
- Keeping every design decision inside one frontier model while delegating only mechanical execution to cheaper models is what makes a $10 website build possible without sacrificing quality.
- The model matters less than the operator — a well-prompted system beats a top-tier model used without one.
- Running a second model as an adversarial reviewer before generation happens catches bad concepts for free, instead of paying to render a bad idea.
- Turning off audio generation is a simple lever that meaningfully cuts AI video credit costs when audio isn't essential to the output.
- A full animated, client-ready product website was generated for around $10 in AI credits, with most of that cost going to video generation rather than design or code.
- Design decisions were the cheapest part of the build; rendering the cinematic motion assets was the expensive part.
- Never let a rented or cheaper model make a creative decision — only let it execute recon, scaffolding, or mechanical checks.
- A repeatable seven-step pipeline — spec, direct, render, gate, build, review, verify — turns a one-shot AI generation into something closer to a QA'd production process.
- Printing a cost receipt (models used, tokens, dollars, credits) at the end of every build makes AI spend visible instead of a surprise bill.
- Getting the first prompt right matters more than any later step, because it's the biggest lever on both output quality and total cost.
The real lesson isn't the model — it's the system around it.
A frontier design model only pays off inside a system that keeps every creative decision on the expensive model and pushes all repetitive execution onto cheaper ones.
- A single well-structured prompt to a top-tier design model can produce a fully animated, scroll-driven website — not just a static layout.
- The variety worth noticing isn't visual polish alone; the same underlying model produced structurally different interaction patterns (progressive reveal, journey/descent narrative, filling animation) from different prompts.
- The best available model loses to a weaker model paired with a skilled operator who understands prompting and skills — the operator is a multiplier, not a formality.
- Treat model choice and prompting skill as two separate levers; most people only ever upgrade the first one.
- Overspending on a frontier model happens easily when there's no cost-tracking system in place — the fix is architectural, not willpower.
- A single design system, once locked, can be reskinned into multiple visually distinct sites without redoing the underlying structure — the leverage is in the system, not the one-off output.
- Split every AI workflow into two lanes: one model allowed to make judgment calls, and other models only allowed to execute — never let a cheaper model touch a decision.
- Run a proposal against a second, independent model as an adversarial check before spending real generation cost — bad ideas get caught in text, not in a rendered asset.
- A repeatable named pipeline (spec, direct, render, gate, build, review, verify) turns a one-shot generation into something with actual quality gates.
- The cheap model's job is prompt scaffolding, cost math, and consistency checking — not creative direction; letting it make creative calls breaks the cost savings.
- Getting the first prompt right the first time is the single biggest lever on total cost — rework compounds through every downstream generation step.
- Video and motion generation, not design or code, is where the real cost sits in an AI-assisted creative pipeline — budget accordingly.
- Turning off unnecessary generation features, like audio, is a free cost reduction when that feature wasn't needed anyway.
Terms worth knowing.
- Fable 5
- The design-specialized Claude model Jack calls the best design AI available; it owns all creative decisions in this workflow — art direction, layout, and code.
- Studio Line
- The four-stage pipeline diagram for the build: Fable 5 (design) leads into Design Skills (the packaged prompt), then Higgsfield (motion rendering), then The Jury (adversarial review) before a site ships.
- Two lanes that never cross
- The rule that Anthropic models hold all design authority while rented models like Higgsfield and GPT-5.6 only execute — they never make creative decisions.
- The Jury
- An adversarial review step where a second AI model critiques a proposed design concept before any expensive rendering happens, catching weak ideas for free.
- Sol (GPT-5.6)
- The nickname given to GPT-5.6 in this system, used as a cheap workhorse for prompt scaffolding, cost math, and mechanical consistency checks — never for design decisions.
- Higgsfield
- A third-party AI media platform used to generate the cinematic video and motion assets embedded in the websites, connected to Claude Code via its CLI.
- Cost receipt
- An end-of-build summary the skill prints showing which models were used, tokens consumed, dollar cost, and remaining credits.
- SSIM-checked gate
- A pipeline step that compares rendered frames using the Structural Similarity Index to catch visual drift before a site ships.
Things they pointed at.
Lines you could clip.
“Claude Fable 5 is the world's best design agent. It builds beautiful, stunning websites that sell for thousands of dollars.”
“Both the driver and the vehicle matter — the best model in the world still loses to a weaker model with a skilled operator behind it.”
“Two lanes, they never cross. Anthropic builds — art direction, brand, fonts, layout, the shot list, the code. The rented models only execute.”
“Opus runs the room, and the cheap models do the reps.”
“The idea gets punched first — before a single frame renders, we run the concept against a second model to sharpen it before a credit is spent.”
“This whole website here cost about $10 — and getting the first prompt right the first time is the most important, most cost-heavy part of the whole process.”
Word for word.
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
The bait, then the rug-pull.
Jack Roberts opens with the promise printed in the title — a single Claude model that builds websites worth thousands — then spends the next twelve minutes showing the actual system: a free skill that chains Fable 5, Higgsfield, and GPT-5.6 into a seven-step pipeline where only Anthropic ever touches a design decision.
Named ideas worth stealing.
The Studio Line
- Fable 5
- Design Skills
- Higgsfield
- The Jury
A four-stage pipeline diagram: the design model, the packaged skill/prompt layer, the animation engine, and an adversarial review jury before a site is called done.
Two lanes that never cross
Anthropic models (Fable 5, Opus) hold 100% of design authority — art direction, brand, fonts, layout, the shot list, the code — while rented models (Higgsfield, GPT-5.6) only execute: render motion, run recon/scaffolding, do mechanical checks.
The idea gets punched first
Before a single frame renders, one model proposes a creative concept and a second, independent model critiques it — a free pre-generation jury that catches weak ideas before real money is spent.
Seven-step build process
- Spec
- Direct the brand and shot
- Render (Higgsfield)
- Gate (SSIM drift check)
- Build (scrub engine)
- Review (design-principle pass)
- Verify (auto-scrolled, frame-timed)
The full pipeline from prompt to shipped site, alternating Anthropic-owned decision steps with mechanical execution steps.
How they asked for the click.
“Come and join me on this video right here where I'll show you the straightest line to making all of that possible.”
Soft end-card pitch pointing to a follow-up video on hosting, client handoff, and scaling the sites — positioned as the natural next step rather than a hard sell.





































































