Video yükleniyor...

Video Yüklenemedi

Ana Sayfaya Dön

Fable 5.2 in Claude Code without burning your weekly limit: the advisor setup. #ClaudeCode #Claude #Fable #AIcoding #vibecoding claude update /advisor fable claude --advisor fable /advisor off "advisorModel": "fable" Your main model (Sonnet 5.5 or Opus 5.5) writes the code, Fable is asked only at decision points, not every...

viralex.aii's profile picture

Arti Miller

10,600 subscribers

10,200 görüntüleme • 4 gün önce •via TikTok

EğitimBilim & Teknoloji#claudecode#claude#fable#aicoding#vibecoding
LIVE

Anya Rossi• Live Now

Private livecam show

0 Yorum

Yorum bulunmuyor

Orijinal gönderinin yorumları burada görünecek

Benzer Videolar

F*ck YES... Anthropic just released most INSANE cheat code for Claude Code: Fable 5.2 brain → while Sonnet 5.5 builds → Opus 5.5 checks → Haiku 5.5 swarms 1 min + /advisor command = up to 3.4x CHEAPER here's how to setup it: first understand how it works: • This setup works for any tasks: Sonnet 5.5 builds, Opus 5.5 immediently check it, Haiku 5.5 swarm of agent search make research - at 80x cheaper per token than Fable • Fable 5.2 never writes code, it wakes up only 3 times: before a plan locks, when an error repeats, before "done" • you pay Fable prices only for decisions, the cheap models do all the rest here's how to setup it: 1 → run Claude update, Fable 5.2 needs Claude Code v2.1.321+ 2 → paste prompt below into Claude Code, it reads Anthropic's official advisor docs first 3 → it sets team at user level, so it works in every project: Sonnet main, Fable advisor, Haiku for subagents, a Opus checker 4 → it backs up your settings and shows every change as a diff before it applies it 5 → the part nobody tells you: there's one line that tells Sonnet 5.5 WHEN to call Fable. Without it, the advisor got called 0 times out of 198 in Anthropic's test full prompt + Anthropic's official advisor docs below Then read article to use Fable 5.2 at max out:
0:25

F*ck YES... Anthropic just released most INSANE cheat code for Claude Code: Fable 5.2 brain → while Sonnet 5.5 builds → Opus 5.5 checks → Haiku 5.5 swarms 1 min + /advisor command = up to 3.4x CHEAPER here's how to setup it: first understand how it works: • This setup works for any tasks: Sonnet 5.5 builds, Opus 5.5 immediently check it, Haiku 5.5 swarm of agent search make research - at 80x cheaper per token than Fable • Fable 5.2 never writes code, it wakes up only 3 times: before a plan locks, when an error repeats, before "done" • you pay Fable prices only for decisions, the cheap models do all the rest here's how to setup it: 1 → run Claude update, Fable 5.2 needs Claude Code v2.1.321+ 2 → paste prompt below into Claude Code, it reads Anthropic's official advisor docs first 3 → it sets team at user level, so it works in every project: Sonnet main, Fable advisor, Haiku for subagents, a Opus checker 4 → it backs up your settings and shows every change as a diff before it applies it 5 → the part nobody tells you: there's one line that tells Sonnet 5.5 WHEN to call Fable. Without it, the advisor got called 0 times out of 198 in Anthropic's test full prompt + Anthropic's official advisor docs below Then read article to use Fable 5.2 at max out:

codila

208,358 görüntüleme • 4 gün önce

Claude Fable 5 is best used as an orchestrator that does the heavy reasoning and delegates token intensive but simpler tasks to cheaper models. 'fable-advisor' is your free and open-source plugin that does exactly that. New in fable-advisor: > A directive to Fable to minimize its own token usage (works surprisingly well) > GPT-5.5 as an implementer sub-agent via the Codex CLI (uses your ChatGPT sub so you don't pay extra) How to use it: 1. claude plugin marketplace add DannyMac180/fable-advisor && claude plugin install fable-advisor 2. /model fable
0:27

Claude Fable 5 is best used as an orchestrator that does the heavy reasoning and delegates token intensive but simpler tasks to cheaper models. 'fable-advisor' is your free and open-source plugin that does exactly that. New in fable-advisor: > A directive to Fable to minimize its own token usage (works surprisingly well) > GPT-5.5 as an implementer sub-agent via the Codex CLI (uses your ChatGPT sub so you don't pay extra) How to use it: 1. claude plugin marketplace add DannyMac180/fable-advisor && claude plugin install fable-advisor 2. /model fable

Dan McAteer

56,732 görüntüleme • 4 ay önce

Claude Fable 5.2 just dropped. So I gave it and Opus 5.5 the same seven builds, one shot each. Fable beat Opus on almost every one. It also cost two to three times more per build. The setup I'd use instead: 1. Type /model opus in Claude Code 2. Type /advisor fable 3. Give it your biggest job Opus does the building. Fable only steps in at the hard moments and checks the work before it's done. In my tests that used less than half the Fable. It still cost less than running Fable on its own on every build. Most paid plans also get at least one free Fable reset this week. Go to Settings > Usage and tap Reset for free. On Max and Ultra, Fable's advice comes out of your normal plan limits. On Pro it's included until 16 November, then it bills to usage credits. If /advisor fable sends you to /model fable, run that once to say yes, then go back to /model opus. You need Claude Code 2.1.321 or newer, so run claude update first. Comment FABLE and I'll send you the full guide: the advisor setup and every prompt from all seven builds.
0:42

Claude Fable 5.2 just dropped. So I gave it and Opus 5.5 the same seven builds, one shot each. Fable beat Opus on almost every one. It also cost two to three times more per build. The setup I'd use instead: 1. Type /model opus in Claude Code 2. Type /advisor fable 3. Give it your biggest job Opus does the building. Fable only steps in at the hard moments and checks the work before it's done. In my tests that used less than half the Fable. It still cost less than running Fable on its own on every build. Most paid plans also get at least one free Fable reset this week. Go to Settings > Usage and tap Reset for free. On Max and Ultra, Fable's advice comes out of your normal plan limits. On Pro it's included until 16 November, then it bills to usage credits. If /advisor fable sends you to /model fable, run that once to say yes, then go back to /model opus. You need Claude Code 2.1.321 or newer, so run claude update first. Comment FABLE and I'll send you the full guide: the advisor setup and every prompt from all seven builds.

Charlie Hills

11,699 görüntüleme • 4 gün önce

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." ↳
0:25

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 görüntüleme • 1 ay önce

Claude Code tip, and it's absolute free f*cking gold: run Opus 5.5, Sonnet 5.5 and Fable 5.1 as one team and stop burning Opus tokens on routine work the setup in one line: plan on high, delegate on medium, keep Fable on call • who does what > Opus 5.5 on high - plans and ships the code > Sonnet 5.5 on medium - explorer reads code, worker edits and runs tests, researcher pulls docs > Fable 5.1 via /advisor fable - reads the whole session and speaks up only when it matters • when Fable 5.1 steps in -> before a plan: is this the right approach? -> when an error repeats: am I digging in the wrong place? -> before "done": what did I miss? Jev engineering takes it one layer lower: which file, which tool, retry or stop all go to Jev in under half a second, so the big models only see the real forks paste this into Claude Code ↓ "Rebuild my Claude Code setup: 1. Find subagents in ~/.claude/agents and .claude/agents that fit explorer, worker and researcher. Draft only the missing ones. Set each to model: sonnet, effort: medium. List any that pin a different model and leave them 2. In ~/.claude/settings.json set effortLevel to high and advisorModel to fable. 3. Report anything that disables the advisor (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, flag-fetching blockers) and CLAUDE_CODE_EFFORT_LEVEL. Change nothing. 4. Add to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done. Show every change as a diff. No edits until I say go." ↳
0:24

Claude Code tip, and it's absolute free f*cking gold: run Opus 5.5, Sonnet 5.5 and Fable 5.1 as one team and stop burning Opus tokens on routine work the setup in one line: plan on high, delegate on medium, keep Fable on call • who does what > Opus 5.5 on high - plans and ships the code > Sonnet 5.5 on medium - explorer reads code, worker edits and runs tests, researcher pulls docs > Fable 5.1 via /advisor fable - reads the whole session and speaks up only when it matters • when Fable 5.1 steps in -> before a plan: is this the right approach? -> when an error repeats: am I digging in the wrong place? -> before "done": what did I miss? Jev engineering takes it one layer lower: which file, which tool, retry or stop all go to Jev in under half a second, so the big models only see the real forks paste this into Claude Code ↓ "Rebuild my Claude Code setup: 1. Find subagents in ~/.claude/agents and .claude/agents that fit explorer, worker and researcher. Draft only the missing ones. Set each to model: sonnet, effort: medium. List any that pin a different model and leave them 2. In ~/.claude/settings.json set effortLevel to high and advisorModel to fable. 3. Report anything that disables the advisor (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, flag-fetching blockers) and CLAUDE_CODE_EFFORT_LEVEL. Change nothing. 4. Add to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done. Show every change as a diff. No edits until I say go." ↳

Mr. Buzzoni

144,764 görüntüleme • 1 ay önce

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." ↳
0:31

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,775 görüntüleme • 1 ay önce

The best way to use Fable right now: > Fable advisor. Sonnet (or Opus) writes the code, Fable is the advisor. Use Fable for the high leverage, lower token judgement. Use Sonnet/Opus for the higher token implementation.
0:20

The best way to use Fable right now: > Fable advisor. Sonnet (or Opus) writes the code, Fable is the advisor. Use Fable for the high leverage, lower token judgement. Use Sonnet/Opus for the higher token implementation.

Dan McAteer

24,774 görüntüleme • 4 ay önce

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." ↳
0:40

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 görüntüleme • 1 ay önce

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." ↳
0:31

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 görüntüleme • 1 ay önce

A viral Claude Code guide claims agent teams cut token use, but Anthropic's documentation says teams use significantly more tokens than a single session. → Agent teams are experimental and turn on with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1, and each teammate has its own context window → There is no --teammates flag: users ask Claude for teammates in plain language, and custom roles go in subagent definitions → The token saver is the advisor tool, where a cheaper main model consults Opus or Fable only at key decision points → The advisor turns on with /advisor opus, the advisorModel setting or claude --advisor opus Source:
0:24

A viral Claude Code guide claims agent teams cut token use, but Anthropic's documentation says teams use significantly more tokens than a single session. → Agent teams are experimental and turn on with CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1, and each teammate has its own context window → There is no --teammates flag: users ask Claude for teammates in plain language, and custom roles go in subagent definitions → The token saver is the advisor tool, where a cheaper main model consults Opus or Fable only at key decision points → The advisor turns on with /advisor opus, the advisorModel setting or claude --advisor opus Source:

0xMarioNawfal

49,119 görüntüleme • 1 ay önce

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." ↳
0:24

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 görüntüleme • 1 ay önce

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." ↳
0:31

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 görüntüleme • 1 ay önce

Claude Code tip that's pure f*cking treasure: Opus 5.5 + Sonnet 5.5 + Fable 5.1 as one team plan on high, delegate on medium, keep Fable on call the team: • Opus 5.5 (high) - plans and ships • Sonnet 5.5 (medium) - explores, edits, runs tests, pulls docs • Fable 5.1 (/advisor fable) - watches the session, speaks up when it counts Fable wakes up 3 times: 1. before a plan - is this the right approach? 2. when an error repeats - am I digging in the wrong place? 3. before "done" - what did I miss? Jev engineering goes one layer lower: which file, which tool, retry or stop go to Jev in under half a second, so the big models only see the real forks paste this into Claude Code 👇 "Rebuild my Claude Code setup around one team. 1. Subagents - reuse anything in ~/.claude/agents and .claude/agents that fits explorer, worker or researcher, draft the rest - all on model: sonnet, effort: medium - explorer and researcher read-only (Read, Grep, Glob, WebFetch), only worker gets Edit and Bash - each returns under 15 lines with file:line refs 2. Main session - in ~/.claude/settings.json set effortLevel to high and advisorModel to fable - report anything that overrides this (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, CLAUDE_CODE_EFFORT_LEVEL) and change nothing 3. Add to ~/.claude/CLAUDE.md - consult the advisor before a plan touching 3+ files, when the same error shows up twice, and before calling a long task done - never let two subagents edit the same file Run /agents to confirm, then show everything as one diff. No edits until I say go." ↳
0:24

Claude Code tip that's pure f*cking treasure: Opus 5.5 + Sonnet 5.5 + Fable 5.1 as one team plan on high, delegate on medium, keep Fable on call the team: • Opus 5.5 (high) - plans and ships • Sonnet 5.5 (medium) - explores, edits, runs tests, pulls docs • Fable 5.1 (/advisor fable) - watches the session, speaks up when it counts Fable wakes up 3 times: 1. before a plan - is this the right approach? 2. when an error repeats - am I digging in the wrong place? 3. before "done" - what did I miss? Jev engineering goes one layer lower: which file, which tool, retry or stop go to Jev in under half a second, so the big models only see the real forks paste this into Claude Code 👇 "Rebuild my Claude Code setup around one team. 1. Subagents - reuse anything in ~/.claude/agents and .claude/agents that fits explorer, worker or researcher, draft the rest - all on model: sonnet, effort: medium - explorer and researcher read-only (Read, Grep, Glob, WebFetch), only worker gets Edit and Bash - each returns under 15 lines with file:line refs 2. Main session - in ~/.claude/settings.json set effortLevel to high and advisorModel to fable - report anything that overrides this (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, CLAUDE_CODE_EFFORT_LEVEL) and change nothing 3. Add to ~/.claude/CLAUDE.md - consult the advisor before a plan touching 3+ files, when the same error shows up twice, and before calling a long task done - never let two subagents edit the same file Run /agents to confirm, then show everything as one diff. No edits until I say go." ↳

Annatar.md

19,580 görüntüleme • 1 ay önce

Claude Code tip: keep Opus 5.5 as your main model, but stop paying Opus prices for your subagents move them to Sonnet 5.5 Opus 5.5 plans and decides Sonnet 5.5 subagents do the heavy reading, editing and testing at half the price ($2 / $10 vs $4 / $20 per 1M tokens) Fable 5.1 stays on call with /advisor 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? Opus thinks. Sonnet does. Fable checks 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 > worker edits and runs tests > researcher pulls the docs > all three on Sonnet 5.5, 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: claude-sonnet-5-5, effort: medium > List any that pin a different model before changing them 2. Keep the main session on Opus, set effortLevel to high in ~/.claude/settings.json and 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." ↳
0:32

Claude Code tip: keep Opus 5.5 as your main model, but stop paying Opus prices for your subagents move them to Sonnet 5.5 Opus 5.5 plans and decides Sonnet 5.5 subagents do the heavy reading, editing and testing at half the price ($2 / $10 vs $4 / $20 per 1M tokens) Fable 5.1 stays on call with /advisor 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? Opus thinks. Sonnet does. Fable checks 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 > worker edits and runs tests > researcher pulls the docs > all three on Sonnet 5.5, 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: claude-sonnet-5-5, effort: medium > List any that pin a different model before changing them 2. Keep the main session on Opus, set effortLevel to high in ~/.claude/settings.json and 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

28,222 görüntüleme • 1 ay önce

this is straight f*cking gold for anyone on Claude Code you already pay for Fable 5.1, and while Opus 5.5 does all the work it just sits there one command puts it on your session as a senior reviewer: /advisor fable Opus 5.5 keeps writing the code Fable 5.1 reads the whole session, every tool call included, and speaks up at three moments only: > 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 does the same thing one layer down: 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 actually 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" ↳
0:24

this is straight f*cking gold for anyone on Claude Code you already pay for Fable 5.1, and while Opus 5.5 does all the work it just sits there one command puts it on your session as a senior reviewer: /advisor fable Opus 5.5 keeps writing the code Fable 5.1 reads the whole session, every tool call included, and speaks up at three moments only: > 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 does the same thing one layer down: 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 actually 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" ↳

Annatar.md

74,551 görüntüleme • 1 ay önce

This is the best way to use Claude Fable in Claude Code without immediately hitting your limits. 1. Model set to Fable 5 2. Reasoning on Max 3. Instruct Claude to run a dynamic workflow where: 3a. Fable is the orchestrator 3b. Opus does the reasoning heavy phases Fable is so overpowered that you don't need its intelligence for every step. Let it orchestrate Opus or even Sonnet.
0:24

This is the best way to use Claude Fable in Claude Code without immediately hitting your limits. 1. Model set to Fable 5 2. Reasoning on Max 3. Instruct Claude to run a dynamic workflow where: 3a. Fable is the orchestrator 3b. Opus does the reasoning heavy phases Fable is so overpowered that you don't need its intelligence for every step. Let it orchestrate Opus or even Sonnet.

Dan McAteer

913,612 görüntüleme • 5 ay önce

This is f*cking insane. I spent thousands of dollars before I split my work across three models put Opus 5.5 on the plan, Sonnet 5.5 on the legwork and Fable 5.1 on call, and you stop spending Opus money on jobs it was never needed for who does what: Opus 5.5, high effort: makes the plan and owns the final diff Sonnet 5.5, medium effort, three jobs: explorer reads the code, worker edits files and runs tests, researcher pulls the docs Fable 5.1, through /advisor fable: reads the whole session, but only when it gets called Fable is consulted at three points: → before a plan ships: is this the right approach? → when an error comes back twice: is the search stuck in the wrong place? → before a long task counts as done: what got missed? Jev engineering applies the same split to the smallest decisions. which file to open, which tool to run, retry or stop need no reasoning, so Jev answers them in under half a second and the big models only get the real forks run Opus on everything and you pay it to check whether a file exists paste this into Claude Code: "Rebuild my Claude Code setup around three tiers. Look in ~/.claude/agents and .claude/agents for subagents that already cover explorer, worker and researcher. Create only the missing ones, each with model: sonnet and effort: medium. If an existing one is pinned to another model, list it and leave it alone. In ~/.claude/settings.json, set advisorModel to fable. Set high effort for Opus inside modelSettings for claude-opus-5-5, because a top-level effortLevel does not apply to Opus 5.5. Report, without changing anything: CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY or anything blocking feature-flag fetches, CLAUDE_CODE_EFFORT_LEVEL, which can override subagent effort, and whether Fable as advisor needs a one-time billing consent. If you can't tell, say so. 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. Touch nothing until I say go."
0:24

This is f*cking insane. I spent thousands of dollars before I split my work across three models put Opus 5.5 on the plan, Sonnet 5.5 on the legwork and Fable 5.1 on call, and you stop spending Opus money on jobs it was never needed for who does what: Opus 5.5, high effort: makes the plan and owns the final diff Sonnet 5.5, medium effort, three jobs: explorer reads the code, worker edits files and runs tests, researcher pulls the docs Fable 5.1, through /advisor fable: reads the whole session, but only when it gets called Fable is consulted at three points: → before a plan ships: is this the right approach? → when an error comes back twice: is the search stuck in the wrong place? → before a long task counts as done: what got missed? Jev engineering applies the same split to the smallest decisions. which file to open, which tool to run, retry or stop need no reasoning, so Jev answers them in under half a second and the big models only get the real forks run Opus on everything and you pay it to check whether a file exists paste this into Claude Code: "Rebuild my Claude Code setup around three tiers. Look in ~/.claude/agents and .claude/agents for subagents that already cover explorer, worker and researcher. Create only the missing ones, each with model: sonnet and effort: medium. If an existing one is pinned to another model, list it and leave it alone. In ~/.claude/settings.json, set advisorModel to fable. Set high effort for Opus inside modelSettings for claude-opus-5-5, because a top-level effortLevel does not apply to Opus 5.5. Report, without changing anything: CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY or anything blocking feature-flag fetches, CLAUDE_CODE_EFFORT_LEVEL, which can override subagent effort, and whether Fable as advisor needs a one-time billing consent. If you can't tell, say so. 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. Touch nothing until I say go."

Ryven

49,239 görüntüleme • 1 ay önce

Fable 5.1 orchestrates GPT-5.6 Luna agents. Via the 'fable-advisor' plugin for Claude Code. 1. Fable 5.1 orchestrates 2. GPT-5.6 Luna implements 3. Fable 5.1 reviews Think of it like in-context distillation: give Luna the intelligence of Fable 5.1 at a fraction the cost.
0:30

Fable 5.1 orchestrates GPT-5.6 Luna agents. Via the 'fable-advisor' plugin for Claude Code. 1. Fable 5.1 orchestrates 2. GPT-5.6 Luna implements 3. Fable 5.1 reviews Think of it like in-context distillation: give Luna the intelligence of Fable 5.1 at a fraction the cost.

Dan McAteer

156,614 görüntüleme • 2 ay önce

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code The idea: isolate parallel worktrees across Sonnet, Haiku 5.5, and Fable 5.1, while keeping Opus 5.5 on call as advisor Zero branch collisions and way fewer tokens: every task lands in its own isolated worktree on the right model You just start Claude Code like this: claude --worktree feat-auth --model sonnet --advisor opus here's how it splits: → Sonnet 5.5 builds feature branches: edits code, runs unit tests, and patches endpoints in .claude/worktrees/feat-auth with zero branch collisions → Haiku 5.5 swarms lightweight scouts: maps AST call sites and dependencies across worktrees at 340 tok/s with zero git lock contention → Fable 5.1 runs long-horizon refactors: tackles multi-file engine migrations in .claude/worktrees/fable-engine with discounted $0.25/1M cache reads → Opus 5.5 stays on call as advisor: ingests full multi-worktree transcripts on high-leverage forks and signs off on synthesized diffs before merge → you stop burning Opus context on routine terminal iteration and keep your primary session at a pristine 14k tokens Opus only steps in at three moments: → before a worktree plan locks → when the same test or build error hits twice → before calling it done (signing off on cross-branch PR diffs) Sonnet builds · Haiku scouts · Fable migrates · Opus reviews JEV engineering is the same move one layer down: the forks that need no thinker (which worktree, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 on call as advisor, reviews synthesized diffs before sign-off > Sonnet 5.5 runs feature worktrees and executes code implementations > Haiku 5.5 swarms parallel scouts at 340 tok/s with zero lockup > Fable 5.1 handles autonomous long-horizon refactors in an isolated worktree > .worktreeinclude carries local configs with zero git index corruption > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Configure git worktree isolation under .claude/worktrees using claude --worktree 2. Run the main feature session on Sonnet 5.5 with Opus 5.5 as advisor via --advisor opus 3. Assign long-horizon multi-file refactoring to Fable 5.1 in an isolated worktree with $0.25/1M cache reads 4. Spawn read-only Haiku 5.5 scouts for 340 tok/s AST sweeps and dependency mapping 5. Add one rule to CLAUDE.md: consult the advisor before locking a plan, after the same error twice, and before final PR sign-off 6. Route fast deterministic forks through JEV, show all changes as diffs first. No edits until I say go" ↳ save it, you'll use this every single day
0:25

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code The idea: isolate parallel worktrees across Sonnet, Haiku 5.5, and Fable 5.1, while keeping Opus 5.5 on call as advisor Zero branch collisions and way fewer tokens: every task lands in its own isolated worktree on the right model You just start Claude Code like this: claude --worktree feat-auth --model sonnet --advisor opus here's how it splits: → Sonnet 5.5 builds feature branches: edits code, runs unit tests, and patches endpoints in .claude/worktrees/feat-auth with zero branch collisions → Haiku 5.5 swarms lightweight scouts: maps AST call sites and dependencies across worktrees at 340 tok/s with zero git lock contention → Fable 5.1 runs long-horizon refactors: tackles multi-file engine migrations in .claude/worktrees/fable-engine with discounted $0.25/1M cache reads → Opus 5.5 stays on call as advisor: ingests full multi-worktree transcripts on high-leverage forks and signs off on synthesized diffs before merge → you stop burning Opus context on routine terminal iteration and keep your primary session at a pristine 14k tokens Opus only steps in at three moments: → before a worktree plan locks → when the same test or build error hits twice → before calling it done (signing off on cross-branch PR diffs) Sonnet builds · Haiku scouts · Fable migrates · Opus reviews JEV engineering is the same move one layer down: the forks that need no thinker (which worktree, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 on call as advisor, reviews synthesized diffs before sign-off > Sonnet 5.5 runs feature worktrees and executes code implementations > Haiku 5.5 swarms parallel scouts at 340 tok/s with zero lockup > Fable 5.1 handles autonomous long-horizon refactors in an isolated worktree > .worktreeinclude carries local configs with zero git index corruption > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Configure git worktree isolation under .claude/worktrees using claude --worktree 2. Run the main feature session on Sonnet 5.5 with Opus 5.5 as advisor via --advisor opus 3. Assign long-horizon multi-file refactoring to Fable 5.1 in an isolated worktree with $0.25/1M cache reads 4. Spawn read-only Haiku 5.5 scouts for 340 tok/s AST sweeps and dependency mapping 5. Add one rule to CLAUDE.md: consult the advisor before locking a plan, after the same error twice, and before final PR sign-off 6. Route fast deterministic forks through JEV, show all changes as diffs first. No edits until I say go" ↳ save it, you'll use this every single day

mirku

23,774 görüntüleme • 17 gün önce

Claude Fable 5.2 dropped today. On paper Opus 5.5 is still better at visual coding, so I gave both the exact same 3 aura prompts in Claude Design. Opus first, then the new Fable. Which model won? #claude #anthropic #ai #claudedesign #fable
0:46

Claude Fable 5.2 dropped today. On paper Opus 5.5 is still better at visual coding, so I gave both the exact same 3 aura prompts in Claude Design. Opus first, then the new Fable. Which model won? #claude #anthropic #ai #claudedesign #fable

jarvis

110,700 görüntüleme • 5 gün önce