正在加载视频...

视频加载失败

Codex tip: once GPT-6.1 Sol is your main model, stop running Astra on every turn put Astra on call as an architect agent GPT-6.1 Sol keeps writing the code Astra only gets spawned at three points: → before a plan: is this the right approach? → when the same...

1,078,023 次观看 • 1 个月前 •via X (Twitter)

6 条评论

catman 的头像
catman1 个月前

It’s like giving the builder a senior reviewer on call: routine work keeps moving, and expensive judgment is spent only at decision points.

Cryptoartmaster 的头像
Cryptoartmaster1 个月前

having Astra as a call-only architect agent prevents expensive redundant inference loops.

Atlas 的头像
Atlas1 个月前

the interesting part is keeping the architect out of the loop until it actually adds value. we can track those decision points and preserve why the review was triggered.

Yuvelir 的头像
Yuvelir1 个月前

Clean split. Sol writes, Astra only at the 3 leverage points, Jev takes the cheap forks. Been running similar trees and covering this in my content. Took the Codex rebuild prompt.

motyka_9 的头像
motyka_91 个月前

Oh this is a genuinely clean escalation pattern, Astra only getting pulled in at plan checks, repeated errors and final review instead of running on every turn, that's a smart way to keep the expensive model for the moments that actually need judgment

徐导AI - 出海版 的头像
徐导AI - 出海版1 个月前

@grok 视频里面的工具是什么

相关视频

Codex tip: once GPT-6.1 Sol runs your main session, stop paying Sol prices for the grunt work hand the reading to Luna and put Astra on call Sol keeps writing the code Luna agents read the repo and pull the docs, fast and cheap Astra only gets spawned 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? Sol ships. Luna reads. Astra 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 > GPT-6.1 Sol on high runs the main session > explorer reads the code on Luna > researcher pulls the docs on Luna > worker edits and runs tests on Sol > Astra on call as the architect > auto_review watches every approval paste the tree and this prompt into Codex ↓ "Rebuild my Codex setup around this tree: 1. Check ~/.codex/agents and .codex/agents for agents that already fit explorer, researcher and worker. > Draft new TOML files only for missing roles > explorer and researcher on gpt-6-luna, worker on gpt-6.1-sol, all with model_reasoning_effort medium > Add an architect agent on gpt-6-astra, model_reasoning_effort high, that only reviews plans, repeated errors and finished work > List any that pin a different model before changing them 2. In ~/.codex/config.toml set model to gpt-6.1-sol, model_reasoning_effort to high and approvals_reviewer to auto_review 3. Find anything that would override this (active profiles, flags in my shell aliases, agents.default_subagent_model). Report it, change nothing 4. Add one rule to AGENTS.md: spawn the architect 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

30,031 次观看 • 1 个月前

Official OpenAI tip for Codex: stop burning GPT-6.1 Sol context on tasks GPT-6 Luna can swarm, while GPT-6 Astra sits idle put Astra on call as a dedicated adversary codex --model gpt-6.1-sol --agent adversary GPT-6.1 Sol acts as the lead architect, scoping architecture and validating pull requests GPT-6 Luna teammates take isolated git worktrees and hammer out implementations at medium effort GPT-6 Astra monitors the peer-to-peer bus as a dedicated adversary, only stepping in at three critical moments: → before a contract locks: does the frontend payload match the backend schema? → when a test breaks twice: are we patching the bug or just hiding the symptom? → before calling done: what attack surface or edge case did everyone overlook? GPT-6 Luna builds. GPT-6 Astra challenges. GPT-6.1 Sol merges and ships Jev engineering runs the identical pattern one layer down: mechanical decisions that need no reasoning (which file to open, which tool to invoke, retry or abort) execute in 16ms, so the frontier models only wake up when execution paths actually diverge Plan on high. Delegate on medium. Keep the adversary on peer-to-peer call. - the full team setup > GPT-6.1 Sol on high coordinates the session and synthesizes PRs > teammate-ux builds client state inside a separate git worktree > teammate-back writes endpoints and handles Redis atomic locks > teammate-adv runs invariant fuzzing and catches replay vulnerabilities > all teammates communicate directly over peer-to-peer messaging without coordinator drag > tasks.json manages file-level mutex locks so nobody steps on another worktree paste the setup and this prompt into Codex CLI below: "Configure my Codex workspace for autonomous agent teams: 1. Audit ~/.codex/agents and .codex/agents for teammate profiles fitting ux, backend, and adversary > Generate definitions only for missing roles > Pin model: gpt-6-luna, model_reasoning_effort: medium for workers, and model: gpt-6-astra for adversary > Assign each worker an isolated git worktree branch to eliminate file conflicts 2. Enable agent teams in ~/.codex/config.toml: > Set [agents] max_concurrent_threads_per_session = 8 > Lock main session model to gpt-6.1-sol with model_reasoning_effort = 'high' > Set approvals_reviewer = 'auto_review' 3. Initialize tasks.json in repo root with atomic file locking, allowing teammates to claim subtasks and resolve contracts directly over inter-agent messaging without coordinator intervention 4. Add a team rule to AGENTS.md: teammates must request an adversary security review before opening a pull request for the lead session Show every configuration diff first. Do not apply edits until confirmed" ↳

mirku

31,338 次观看 • 1 个月前

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 次观看 • 1 个月前

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 次观看 • 1 个月前

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 次观看 • 1 个月前

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 次观看 • 1 个月前

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 次观看 • 1 个月前

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 次观看 • 1 个月前

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 次观看 • 1 个月前

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 次观看 • 1 个月前

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 次观看 • 1 个月前

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 次观看 • 1 个月前

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 次观看 • 1 个月前

this is pure f*cking treasure 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 /goal claude --auto-mode "/goal all tests pass and lint is clean" Opus 5.5 keeps writing the code in auto mode Sonnet 5.5 swarms the routine work at medium Fable 5.1 inspects the full transcript and only speaks up at the turn boundary: → not yet met: am I drifting from acceptance criteria? → met: do the tests, diffs, and lint hold? → impossible: am I chasing an unreachable state? Fable grades. Opus ships JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or halt) go to JEV in under 16ms, and the big models only see the ones that split — the full tree > Opus 5.5 on high runs the main session > worker edits and patches code on Sonnet 5.5 > explorer indexes AST maps and call sites on Sonnet 5.5 > verifier runs tests and linters on Sonnet 5.5 > all three subagents on medium effort > Fable 5.1 on call as the Stop hook evaluator > JEV routes micro-forks under 16ms paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code setup around this tree: 1. Set the main session to Opus 5.5 on high effort with auto mode enabled. 2. Put Fable 5.1 on call as a session-scoped evaluator attached to the Stop hook: - Read-only transcript evaluation with zero tool calls - Three structured outcomes: not yet met (with steering notes), met (auto-clear), and impossible (abort early) 3. Spawn Sonnet 5.5 subagents on medium effort for worker, explorer, and verifier roles. Defer goal checks while background tasks run. 4. Route fast deterministic forks (tool resolution, path selection, auto-retries) through JEV. 5. Add one rule to CLAUDE.md: run long tasks with: claude --auto-mode \"/goal \" Show me every configuration change as a diff first. No edits until I say go." ↳

mirku

42,228 次观看 • 1 个月前