Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

Fable 5.5 its over for video and image models 🤯 THIS IS PURE CODE one shotted this video holy shit , how this is more beautiful than ai video models Two ways to check this yourself: Ask: “Where did Andrej Karpathy go in 2026?” with web search and memory...

2,376,307 Aufrufe • vor 10 Tagen •via X (Twitter)

43 Kommentare

Profilbild von Chetaslua
Chetasluavor 10 Tagen

code for review : Prompt : Create a 2D anime scene for the web. It must look completely like real Japanese anime, as if it were taken directly from a finished theatrical anime film. This is traditional-looking, hand-drawn 2D anime, not a 3D animation, a moving illustration, or a stylized web graphic. Deliver the final result as a single, self-contained HTML file. Use any tools, libraries, references, guides, literally anything etc. Use Studio Ghibli films as the art style reference for the design, line work, painted backgrounds, color, and atmosphere. Create an original giant robot as the main character. No people appear in the scene. Use any tools or techniques you want, including 3D, as long as the final result looks 100% like hand-drawn 2D anime. SCENE At sunrise, mist hangs over an abandoned forest. A giant robot has knelt here for so long that moss, wildflowers, and old trees have grown over its body. A small bird lands on its shoulder as the first ray of sunlight reaches its weathered face. Deep inside its chest, a faint light flickers on. The ground trembles and birds burst from the treetops. With a deep, creaking groan, the robot slowly rises as soil, vines, and leaves pour from its armor. It lifts its head toward a gap in the canopy. The engines ignite, sending a great ring of wind across the forest. The robot tears into the golden sky, leaving a curving trail of light and mist as leaves spiral down through the sunbeams. ANIME QUALITY STANDARD Every frame must look as if it was drawn by professional anime animators and painted by master background artists for a finished theatrical film. Robot: A hand-drawn anime mecha that feels heavy, ancient, and full of personality, with cel-colored forms, chipped paint, rust, moss, and believable weathering. Keep it on-model from every angle, and let its posture and glowing eyes express emotion. Line art: Confident, delicate, hand-inked anime line work with subtle variation in thickness and pressure. Coloring: Traditional anime cel coloring with clean color areas, simple hard-edged shadows, and a soft, natural palette. Backgrounds: Richly detailed, hand-painted anime backgrounds in a gouache style, with visible brushwork, natural color variation, layered foliage, and real depth. Lighting: Golden sunrise light, colorful shadows, glowing mist, and soft atmosphere that unite the robot and background. Animation: Authentic hand-drawn anime timing with real weight, strong key poses, natural holds, and overlapping movement in vines, grass, leaves, birds, and falling debris. The robot should rise slowly and feel massive, then launch with explosive power. Direction: Cinematic anime shots, beautiful composition, thoughtful staging, and pacing that starts quietly, builds tension, and ends in a soaring climax. IT MUST NOT LOOK LIKE - 3D: No plastic materials, CGI shading, visible polygons, game-engine lighting, or computer-perfect perspective. - SVG or vector art: No simple geometric shapes, perfect curves, uniform outlines, flat corporate illustration, or basic gradients. - Web animation: No sliding layers, constant bobbing, floating parts, smooth software easing, or puppet-like joint rotation. You are free to change any part of the prompt, if it would result, in better results. - AI art: No warped shapes, melted details, flickering, or changing robot designs. - Non-anime art: No Western cartoon designs, realistic rendering, soft painterly shading on the robot, or generic digital illustration. - Amateur work: No stiff poses, empty backgrounds, repeated trees, muddy colors, clip art, placeholders, or unfinished details. The result should feel awe-inspiring, nostalgic, and full of wonder, like the moment an old forgotten dream comes back to life. Before finishing, inspect random frames as still images. If any frame does not look completely like real 2D anime, keep improving it. Do not stop until every frame could pass as a still from a theatrical anime film.

Profilbild von Chetaslua
Chetasluavor 10 Tagen

fully coded no external assets used and for all of you it made html code block as asked

Profilbild von Chetaslua
Chetasluavor 10 Tagen

thanks tuskedfriend for the work

Profilbild von J A Z I I
J A Z I Ivor 10 Tagen

@karpathy brooo wtfff. this is whole ass animation

Profilbild von Chetaslua
Chetasluavor 10 Tagen

@karpathy its over , 6 more months and nobody will care about new video or image model

Profilbild von Ozan
Ozanvor 10 Tagen

@karpathy What is this!? That's crazy good! It's coming to destroy artists.

Profilbild von J A Z I I
J A Z I Ivor 10 Tagen

@karpathy OMG this looks so good

Profilbild von Chetaslua
Chetasluavor 10 Tagen

@karpathy we are so back

Profilbild von Shawn
Shawnvor 10 Tagen

@karpathy is the new Fable public, or a test build somewhere?

Profilbild von Jesus is God ✝︎
Jesus is God ✝︎vor 10 Tagen

@karpathy Great post, might be one of your best

Profilbild von Prakhar Aggarwal
Prakhar Aggarwalvor 10 Tagen

@karpathy Holy sick 🤯

Profilbild von Olezhka
Olezhkavor 10 Tagen

@karpathy Getting that level of volumetric clouds and pixel shading one-shot is unreal

Profilbild von Ion
Ionvor 10 Tagen

@karpathy What the hell 😳

Profilbild von Moonlit Monkey
Moonlit Monkeyvor 10 Tagen

@karpathy Feels like a sensory lobotomy.

Profilbild von 馒头不是程序员
馒头不是程序员vor 10 Tagen

@karpathy 纯粹的代码一击必杀,这个形容很到位,比AI视频模型还美就说明代码本身的表达力被低估了,关键是这种美是能直接跑起来的,不是光好看。

Profilbild von dragon
dragonvor 10 Tagen

@karpathy It's too exaggerated

Profilbild von Ter
Tervor 10 Tagen

@karpathy Golden age has arrived

Profilbild von 마피 | マフィ | Mafi
마피 | マフィ | Mafivor 10 Tagen

@karpathy Fully coded??

Profilbild von Unama Madita | Building with AI
Unama Madita | Building with AIvor 10 Tagen

@karpathy Wtf

Profilbild von Aditya Batra
Aditya Batravor 10 Tagen

@karpathy thats a 48mb mp4 in a trenchcoat bro, readme says the film is base64 and theres like 9kb of actual code

Profilbild von saietta
saiettavor 10 Tagen

@karpathy opus 5.5 did this for me too, a 41 sec promo video for a product i built, all code. i ran it in the same claude code session where i built the product so it already knew every screen, i only asked for a few visual fixes

Profilbild von jimmi
jimmivor 10 Tagen

@karpathy This is really cool, but it's not as good as what video models can produce. To me it really undermines your credibility and comes across as a lack of taste on your part to state otherwise. Not trying to be mean, you seem like a cool dude, just a little too much hype for me.

Profilbild von Jubayar Adnan
Jubayar Adnanvor 10 Tagen

@karpathy Video was so Amazing 😱

Profilbild von Eric
Ericvor 10 Tagen

@karpathy I wish that you recreate all these prompts when the model is released to confirm if the expectations are correct

Profilbild von AI Adventurer
AI Adventurervor 10 Tagen

@karpathy for anyone opening the repo: index.html carries the film as a ~36 MB base64 MP4 (H.264, 1920x1040, 80 s) decoded into a Blob at load, and the only live canvas is the grain overlay. is the code that rendered the frames going up too?

Profilbild von Edgex
Edgexvor 10 Tagen

@karpathy Totally agree, Grok can’t keep up on niche stuff. Fable’s code‑only approach is a game changer for this kind of reasoning

Profilbild von HandlyTech
HandlyTechvor 10 Tagen

@karpathy video models have died more times than my tamagotchi

Profilbild von Freedom | AI
Freedom | AIvor 10 Tagen

"Over for video models" is a stretch, honestly. Totally different tools. The cool part with code is every frame is computed: the robot never melts or morphs, and if you want a different shot you just tweak a number and re-run. Video models can't touch that. But you can see the limits too. The takeoff smoke is pretty obviously a few stacked sprites. Curious though: were those painterly assets drawn in code, or just loaded images? Kinda decides how "pure code" this really is.

Profilbild von Chetaslua
Chetasluavor 10 Tagen

@karpathy its not loaded images that for sure

Profilbild von Furkan Ceyran
Furkan Ceyranvor 10 Tagen

@karpathy Video modelleriyle anime oluşturmaya ne zaman başlayacağız derken ne kadar vizyonsuzmuşum 🤦

Profilbild von Minto
Mintovor 10 Tagen

@karpathy A clean one-shot is the easy number to show off. I'd care more about whether the tenth rerun looks like the first, since consistency across attempts is usually where video models fall apart.

Profilbild von Arbaz
Arbazvor 10 Tagen

@karpathy shot or the best of ten one shots?

Profilbild von Friendly Lootera
Friendly Looteravor 10 Tagen

@karpathy Giving studio Ghibli vibes

Profilbild von CDG
CDGvor 10 Tagen

@karpathy damnn bruh ts looks so good!

Profilbild von zhod
zhodvor 10 Tagen

@karpathy This is cleannn

Profilbild von BubbleBrain
BubbleBrainvor 10 Tagen

@karpathy this looks incredible!

Profilbild von ccod
ccodvor 10 Tagen

@karpathy one shot of pure code and it looks better than my video models tenth try

Profilbild von AI Fine Print
AI Fine Printvor 10 Tagen

@karpathy Oh my. If this really turns out to be what they ship as Fable 5.5 then the leap in capabilities is insane. Not saying we should all use it as a video model, but the reasoning and detail behind creating this shows a badass capable model.

Profilbild von İcarus#HλlfLifeBekliyor
İcarus#HλlfLifeBekliyorvor 10 Tagen

@karpathy İmpressive i like to see someone do animation with it to see its performance

Profilbild von Louis LAURENT
Louis LAURENTvor 10 Tagen

@karpathy chetas please use it for motion design ull make millions of views

Profilbild von Chetaslua
Chetasluavor 10 Tagen

@karpathy like

Profilbild von Louis LAURENT
Louis LAURENTvor 10 Tagen

@karpathy :)

Profilbild von Louis LAURENT
Louis LAURENTvor 10 Tagen

@karpathy 1. recreating oai video launch 2. full motion like recreate a well known launch video

Ähnliche Videos

This is f*cking insane. This Claude Code tip saved me thousands of dollars. once Opus 5.5 is your main model, stop burning it on work Sonnet 5.5 can do, while Fable 5.1 sits idle hand the grunt work to Sonnet 5.5 subagents and put Fable 5.1 on call run /advisor fable Opus 5.5 plans and ships the final code Sonnet 5.5 subagents read, edit and run the tests Fable 5.1 reads the full session, every tool call included, and only speaks up at three points: → before a plan: is this the right approach? → when the same error comes back: am I digging in the wrong place? → before "done": what did I miss? Sonnet 5.5 builds. Fable 5.1 reviews. Opus 5.5 ships Jev engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to Jev in under half a second, and the big models only see the ones that split anyone still running one model for everything is paying Opus prices to decide whether a file exists - the full tree > Opus 5.5 on high runs the main session > explorer reads the code on Sonnet 5.5 > worker edits and runs tests on Sonnet 5.5 > researcher pulls the docs on Sonnet 5.5 > all three on medium > Fable 5.1 on call for main and every subagent paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Check ~/.claude/agents and .claude/agents for subagents that already fit explorer, worker and researcher. > Draft new ones only for missing roles > Give each model: sonnet, effort: medium > Skip any that pin a different model and list them 2. Set the main session to high via effortLevel in ~/.claude/settings.json, and set advisorModel to fable 3. Find anything that keeps the advisor off (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY) plus CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report them, change nothing 4. Add one rule to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done Show me every change as a diff first. No edits until I say go." ↳

delost

48,964 Aufrufe • vor 1 Monat

Official Anthropic tip for Claude Code: stop burning Opus 5.5 on work Sonnet 5.5 can do, while Fable 5.1 sits idle hand the grunt work to Sonnet 5.5 subagents and put Fable 5.1 on call run /advisor fable Opus 5.5 plans and merges Sonnet 5.5 subagents read, edit and run the tests Fable 5.1 reads the full session and only speaks up at three points: → before a plan: is this the right approach? → when the same error comes back: am I digging in the wrong place? → before "done": what did I miss? Sonnet 5.5 builds. Fable 5.1 reviews. Opus 5.5 ships Jev engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to Jev in under half a second, and the big models only see the ones that split - the full tree > Opus 5.5 on high runs the main session > explorer reads the code on Sonnet 5.5 > worker edits and runs tests on Sonnet 5.5 > researcher pulls the docs on Sonnet 5.5 > all three on medium > Fable 5.1 on call for main and every subagent paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Check ~/.claude/agents and .claude/agents for subagents that already fit explorer, worker and researcher. > Draft new ones only for missing roles > Give each model: sonnet, effort: medium > Skip any that pin a different model and list them 2. Set the main session to high via effortLevel in ~/.claude/settings.json, and set advisorModel to fable 3. Find anything that keeps the advisor off (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY) plus CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report them, change nothing 4. Add one rule to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done Show me every change as a diff first. No edits until I say go." ↳

delost

44,284 Aufrufe • vor 1 Monat

GPT-5.6 vs GPT-5.5 on my custom spaceship prompt. I gave both models the exact same custom prompt. This is also the same prompt I previously gave to Fable 5. For context, GPT-5.6 Pro worked for 87 minutes, while GPT-5.5 Extra High worked for 34 minutes and 42 seconds. As I’ve said before, based on great authority GPT-5.6 will be an incremental/soldi improvement over GPT-5.5, not a “Fable killer.” My rough expectation has been that it would trade blows with Fable 5 on some benchmarks, maybe win around half depending on the category, but not clearly surpass it overall. And again fable five will have bigger model smell, but this was expected. After testing this coding output, that view feels pretty accurate. GPT-5.6 is clearly better than GPT-5.5 in several visual areas. The lighting, shading, chairs, object details, and exterior of the spaceship looked noticeably stronger. The scene was also easier to test. I do want to give GPT-5.5 credit though. It built out the rooms much much better and the planets looked better than GPT-5.6’s. It was also interesting that both GPT-5.5 and GPT-5.6 produced better-looking planets than Fable 5 in this specific test. The downside with GPT-5.5 was stability. The game was much glitchier and harder to test compared to GPT-5.6. But when it comes to the core of the demo, which is the spaceship itself, Fable 5 still beat both models pretty comfortably. GPT-5.6 is impressive, but from this test, it looks exactly like what I expected which was a meaningful incremental improvement over GPT-5.5, at least for indie game demos, but not something that replaces Fable 5. In collaboration with Chetaslua

Chris

250,919 Aufrufe • vor 4 Monaten

Claude Code tip: once Opus 5.5 is your main model, stop leaving Fable 5.1 sitting idle and stop burning Opus tokens on tasks Sonnet 5.5 can swarm put it on call with /advisor run /advisor fable Opus 5.5 plans and ships the code Sonnet 5.5 swarms the routine work at medium effort Fable 5.1 reads the full session, every tool call included, and only speaks up at three points: → before a plan: is this the right approach? → when the same error comes back: am I digging in the wrong place? → before "done": what did I miss? Fable 5.1 reviews. Sonnet 5.5 executes. Opus 5.5 ships Jev engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to Jev in under half a second, and the big model only sees the ones that split Plan on high. Delegate on medium. Keep Fable on call. - the full tree > Opus 5.5 on high runs the main session > explorer reads the code > worker edits and runs tests > researcher pulls the docs > all three on Sonnet 5.5 at medium effort > Fable 5.1 on call as the advisor paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Check ~/.claude/agents and .claude/agents for subagents that already fit explorer, worker and researcher. > Draft new ones only for missing roles > Give each model: sonnet, effort: medium > Skip any that pin a different model and list them 2. Set the main session to high via effortLevel in ~/.claude/settings.json, and set advisorModel to fable 3. Find anything that keeps the advisor off (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, any variable that stops feature-flag fetching) plus CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report them, change nothing 4. Add one rule to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done Show me every change as a diff first. No edits until I say go." ↳

mirku

424,860 Aufrufe • vor 1 Monat

Claude Code tip: once Opus 5.5 is your main model, stop leaving Fable 5.1 sitting idle put it on call with /advisor run /advisor fable Opus 5.5 keeps writing the code Fable 5.1 reads the full session, every tool call included, and only speaks up at three points: → before a plan: is this the right approach? → when the same error comes back: am I digging in the wrong place? → before "done": what did I miss? Fable 5.1 reviews. Opus 5.5 ships Jev engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to Jev in under half a second, and the big model only sees the ones that split - the full tree > Opus 5.5 on high runs the main session > explorer reads the code > worker edits and runs tests > researcher pulls the docs > all three on medium > Fable 5.1 on call as the advisor paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Check ~/.claude/agents and .claude/agents for subagents that already fit explorer, worker and researcher. > Draft new ones only for missing roles > Give each model: opus, effort: medium > Skip any that pin a different model and list them 2. Set the main session to high via effortLevel in ~/.claude/settings.json, and set advisorModel to fable 3. Find anything that keeps the advisor off (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, any variable that stops feature-flag fetching) plus CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report them, change nothing 4. Add one rule to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done Show me every change as a diff first. No edits until I say go." ↳

delost

701,333 Aufrufe • vor 1 Monat

Claude Code tip: once Opus 5.5 is your main model, stop letting your Fable 5.1 quota go to waste put it on call with /advisor run /advisor fable Opus 5.5 keeps doing the work Fable 5.1 sits on the sidelines, reads the whole session, and steps in at three moments: → before a plan: is this right? → when the same error comes back: am I going the wrong way? → before "done": did I miss anything? Fable 5.1 advises. Opus 5.5 writes the code the same idea sits under Jev engineering: the expensive model stops weighing in on every step and only gets called at the moments that change the outcome • the full setup > Opus 5.5 on high runs the main session > subagent one reads code > subagent two edits and runs tests > subagent three looks up docs > all three on medium > Fable 5.1 on call hand the tree and this prompt to Claude Code 👇 "Set up my Claude Code to match this tree: 1. Reuse fitting subagents from ~/.claude/agents and .claude/agents. > Propose new ones only for missing roles > Set each to model: opus, effort: medium > Leave any that set a different model alone and list them 2. Set main session effort to high via effortLevel in ~/.claude/settings.json 3. Check for env vars that disable the advisor (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, anything that stops flag fetching) and CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report them, don't change them 4. Add a rule to ~/.claude/CLAUDE.md: ask the advisor before a big plan, when an error repeats, and before calling a long task done Show me the changes first. Don't edit files yet." ↳

Mr. Buzzoni

327,334 Aufrufe • vor 1 Monat

Claude Code tip: once Opus 5.5 runs your main session, stop leaving Fable 5.1 on the bench put it on call with /advisor run /advisor fable Opus 5.5 keeps writing the code Fable 5.1 reads the whole session, every tool call included, and only speaks up at three moments: → before a plan: is this the right approach? → when the same error comes back: am I digging in the wrong place? → before "done": what did I miss? Fable 5.1 reviews. Opus 5.5 ships jev engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to jev in under half a second, and the big model only sees the ones that split - the full tree > Opus 5.5 on high runs the main session > explorer reads the code > worker edits and runs tests > researcher pulls the docs > all three on medium > Fable 5.1 on call as the advisor paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Check ~/.claude/agents and .claude/agents for subagents that already fit explorer, worker and researcher. > Draft new ones only for missing roles > Give each model: opus, effort: medium > Skip any that pin a different model and list them 2. Set the main session to high via effortLevel in ~/.claude/settings.json, and set advisorModel to fable 3. Find anything that keeps the advisor off (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, any variable that stops feature-flag fetching) plus CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report them, change nothing 4. Add one rule to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done Show me every change as a diff first. No edits until I say go." ↳

Hanako

52,065 Aufrufe • vor 1 Monat

THIS IS ACTUAL F*CKING GOLD Anthropic just shared one of the best tips for Claude Code The idea: configure model routing so Opus 5.5, Sonnet 5.5, Haiku 5.5 and Fable 5.1 each do only what they are built for Opus-level intelligence on every big architectural call, without paying Opus token rates for routine terminal turns You just configure your models in Claude Code like this: /model here's how it splits: → Opus 5.5 runs the main session on high effort to design architecture and synthesize pull requests → Sonnet 5.5 implements features and runs test suites at balanced medium effort → Haiku 5.5 tears through file sweeps and AST lookups at 340 tok/s → Fable 5.1 monitors on call as a dedicated adversary to challenge assumptions Fable 5.1 only steps in at three moments: → before a plan locks: is this the right model tier and approach? → when the same error repeats twice: are we fixing the root cause or patching symptoms? → before calling done: what edge cases or security invariants did everyone overlook? Opus 5.5 plans. Sonnet 5.5 builds. Haiku 5.5 scans. Fable 5.1 audits JEV engineering is the same move one layer down: the forks that need no thinker (which file to open, which tool to invoke, retry or stop) resolve in 16ms, so frontier models only wake up when execution paths actually diverge the full tree > Opus 5.5 on high coordinates the session and locks architecture > worker implements code changes on Sonnet 5.5 at medium effort > search maps repository call sites on Haiku 5.5 at 340 tok/s > Fable 5.1 on call as advisor audits transcripts and catches regressions > ~/.claude/settings.json maps persistent model aliases across all projects > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code model setup around this tree: 1. In ~/.claude/settings.json, configure default models: set Opus 5.5 as main lead with effortLevel high, and Fable 5.1 as advisorModel 2. Map subagent roles: pin model: sonnet, effort: medium for workers, and model: haiku for read-only AST scanners 3. Set up environment aliases for ANTHROPIC_DEFAULT_OPUS_MODEL, ANTHROPIC_DEFAULT_SONNET_MODEL, ANTHROPIC_DEFAULT_HAIKU_MODEL, and ANTHROPIC_DEFAULT_FABLE_MODEL 4. Add one rule to CLAUDE.md: consult Fable 5.1 before locking a plan, after the same error twice, and before marking a task done 5. Route fast deterministic forks (tool choice, path selection, retries) through JEV Show me every change as a diff first. No edits until I say go" ↳ save it, you'll use this every single day

mirku

11,371 Aufrufe • vor 6 Tagen

I don't understand why everyone isn't doing this yet. Anthropic's own Claude Code docs show how to run a whole team of Claudes, while Opus 5.5 only touches the plan and the merge the whole idea: agent teams in Claude Code one lead, separate teammates in their own context windows, one shared task list, and they message each other directly the lead: Opus 5.5 on high, splits the work, writes the tasks, merges at the end the builders: Sonnet 5.5, one owns client/, one owns api/, never the same file the adversary: Fable 5.1, never writes code, only shows up at three points: → before an interface locks: do both sides agree on the contract? → when a test fails twice: is it fixed or just hidden? → before a task is marked done: what breaks it? Sonnet 5.5 builds. Fable 5.1 attacks. Opus 5.5 merges Jev engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to Jev in under half a second, and the team only argues about the ones that split turn it on, then start the team in plain English: "Spawn three teammates: ux and backend on Sonnet, an adversary on Fable" - the full team > Opus 5.5 on high leads the session > ux on Sonnet 5.5, owns client/ > backend on Sonnet 5.5, owns api/ > adversary on Fable 5.1, owns nothing, reviews everything > shared task list with file locking, direct messages, no lead in the middle paste the team and this prompt into Claude Code ↓ "Set up agent teams for this repo: 1. In ~/.claude/settings.json add CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 under env and set effortLevel to high 2. In ~/.claude/agents, draft three subagent definitions for the teammates > ux and backend with model: sonnet, each limited to its own folder > adversary with model: fable and read-only tools, whose only job is attacking contracts, repeated test failures and done claims > Skip any that already exist and list them 3. Add a TaskCompleted hook that blocks completion until the adversary signs off, and one rule to CLAUDE.md: no two teammates edit the same file 4. Find anything that would override this (CLAUDE_CODE_SUBAGENT_MODEL, CLAUDE_CODE_SUBAGENT_MODEL_FORCE, CLAUDE_CODE_EFFORT_LEVEL). Report it, change nothing Show me every change as a diff first. No edits until I say go." ↳

delost

71,067 Aufrufe • vor 1 Monat

This workflow will save you thousands with Claude. Run Opus 5.5, Sonnet 5.5, Haiku 5.5, and Fable 5.1 together, and stop spending Opus tokens on work that doesn't need Opus. The entire idea in one line: Opus plans, Sonnet edits, Haiku reads, Fable reviews at decision points. Roles, broken down: - Opus 5.5, high effort, owns the plan and reviews the final code - Sonnet 5.5, medium effort, is the worker: edits files, runs tests - Haiku 5.5, low effort, splits into explorer (searches and reads the codebase) and researcher (pulls docs). it's the first Haiku with an effort setting - Fable 5.1, set with /advisor fable. Opus calls it at decision points, and it gets the full transcript each time Three moments Opus tends to call it: → before committing to a plan: is this the right approach? → the same error shows up again: is this going nowhere? → before marking the task done: did something get skipped? Why Haiku only reads: Anthropic's launch post says Sonnet 5.5 and Opus 5.5 are still the better choice for complex agentic coding (Terminal-Bench 4.0: 39.2% for Haiku 5.5, 70.6% for Sonnet 5.5) and that Haiku 5.5 fits narrowly scoped subagent work. so it gets the lookups, not the edits. Anyone still running one model for everything is paying $4 per million input tokens to check whether a file exists. Haiku 5.5 does it for $0.10. Drop this into Claude Code 👇 "Rebuild my Claude Code setup around this structure: Confirm Claude Code is v2.1.293 or later, so the haiku alias resolves to Haiku 5.5. If it isn't, stop and tell me to run claude update. Look through ~/.claude/agents and .claude/agents for subagents already covering explorer, worker, and researcher. Only create new ones for roles that are missing. Set model: haiku, effort: low on explorer and researcher, with no Edit or Write tools. Set model: sonnet, effort: medium on worker. If an existing subagent is locked to a different model, leave it as is and just list it. Name the explorer subagent Explore so it overrides the built-in one, which otherwise runs on my main model. In ~/.claude/settings.json, set advisorModel to fable, and set effortLevel to high for claude-opus-5-5 under modelSettings. A top-level effortLevel in user settings doesn't apply to Opus 5.5. Check for anything disabling the advisor: CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, or anything blocking feature-flag fetches. Also check CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort settings, and CLAUDE_CODE_SUBAGENT_MODEL_FORCE, which makes Claude Code ignore subagent model fields. Report what you find. Don't change any of it yet. Add one line to ~/.claude/CLAUDE.md: consult the advisor before a big plan, when the same error shows up twice, and before marking a long task done. Show every change as a diff first. Wait for my go-ahead before touching anything."

Alvaro Cintas

58,450 Aufrufe • vor 1 Monat