Claude Code's effort parameter is something you need to... keep in mind before starting any task It's not just about picking the right model anymore (Haiku, Sonnet, Opus). Now you also need to think about which effort level to use before each task. One tip I always go back to: when Opus can't solve a problem, just adding ultrathink makes things click, it's almost magic. We wrote a post at Hedgineer benchmarking each effort level by cost and time Read it here:show more

Jev + Opus 5.5 is the most underrated setup... in AI right now, and i don't get why nobody's talking about it. I stopped letting Opus make every small decision in my agents. Jev makes them now. My Opus bill dropped ~500% on the same tasks, same results. Here's what Jev handles: - which files and notes to load before Opus sees anything - which effort level each task actually needs - what to do when a tool fails - which tests to run, and when to stop Opus only gets called for the hard reasoning. Every decision is a typed result the host checks before it runs. The exact prompt to set this up in your workflow is below.show more

Sonnet 5 is here. It's worse than Opus 4.8... on nearly every benchmark... Does that mean it's useless? Absolutely not. Use it with Claude Code Dynamic Workflows! 1. /model set to Sonnet 5 2. /effort set to Ultracode 3. Any complex task will kick off a dynamic workflow This will only become more powerful when Fable is back. You'll use Fable 5 as the superintelligent advisor and Sonnet 5 as the fast and efficient implementer.show more

it's f*cking insane.. Anthropic just dropped a Claude Code... setup that makes tokens up to 97% cheaper Opus brains, Sonnet bill: > Sonnet runs your session and writes the code > Haiku subagents grab the small tasks > Opus steps in only when Sonnet gets stuck > it checks the work, digs into the problem and puts Sonnet back on track $19.50 saved on every 1M tokens a Haiku 5.5 subagent writes, compared with Opus 5.5 one command sets it up: npx claude-code-templates@latest --setting model/sonnet-opus-advisor-haiku-subagents the easiest money you'll save on Claude Code this yearshow more

ANTHROPIC JUST DROPPED THE OFFICIAL GUIDE TO PROMPTING OPUS... 5 This is the most important prompting guide for anyone using Claude. Bookmark this before you forget. Most people still prompt Opus 5 like older models. That's the mistake. > give the complete task upfront — don't drip-feed instructions. > explicitly ask for shorter responses if you want them. > use low/medium effort by default. increase effort only when needed. > let it finish the entire feature instead of asking for partial implementations. > use subagents intentionally for large codebases, not every task. Opus 5 is at its best when you stop micromanaging it and let it own the work. Read it before writing your next prompt. Claude → Opus 5 → Agentic Execution → Production-Ready Output → Moneyshow more

THIS IS F*CKING BRILLIANT. Anthropic’s docs describe one of... the smartest ways to run Opus three models work on one task and each does only the part it’s cheapest at. start Claude Code like this: claude -> model sonnet -> advisor opus you stop paying Opus prices for work that doesn’t need Opus > Sonnet runs the session and edits the code > Haiku 5.5 searches the repo and docs, at up to 40x less per token than Opus 5.5 > Opus waits as the advisor and reads the whole session, tool calls included Claude usually calls Opus at three points: > before it locks a plan > when the same error comes back > right before it says it’s done Sonnet drives. Haiku scouts. Opus signs off and if you go one step lower, most of an agent’s day is tiny choices like picking a file or a tool, or deciding whether to retry. Jev takes those first, so Sonnet and Opus only see the moments that are really open the whole setup Sonnet runs the main session Explore on Haiku 5.5 searches and pulls docs, read-only Opus on call as the advisor give Claude Code this setup and the prompt below ↓ “Set up my Claude Code exactly like this: Main model Sonnet, advisor Opus, saved as advisorModel in my settings. One read-only subagent named exactly Explore, on claude-haiku-5-5, to replace the built-in one. One line in CLAUDE.md: ask the advisor before locking a plan, after the same error twice, and before calling a task done, not more often. Check what could turn the advisor off (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY) and only report it. Show every change as a diff first. Don’t edit anything until I say go.” before you turn it on: every advisor call re-reads the whole transcript with no cache. on a 200k session that’s about $0.80 in input, against $0.04 for a normal request. keep it to a few calls the built-in Explore agent runs on your main model unless a subagent is named exactly Explore. any other name does nothing turning the advisor on or off keeps your prompt cache. switching models rebuilds it it needs the Anthropic API, and it stays off if telemetry is disabled bookmark it before your next long sessionshow more

This is f*cking insane. This tip saved me thousands... of dollars. run Opus 5.5, Sonnet 5.5, and Fable 5.1 together, and stop burning Opus on work it was never needed for. the whole idea in one line: the strong model plans, the mid-tier model executes, Fable stays quiet until it's actually needed. roles, broken down: Opus 5.5, high effort, owns the plan and ships the final code Sonnet 5.5, medium effort, splits into explorer (reads the codebase), worker (edits files, runs tests), researcher (pulls docs) Fable 5.1, called through /advisor fable, reads everything happening in the session but stays silent unless something's actually wrong three moments where Fable speaks: → a plan goes out: is this actually the right call? → the same failure shows up again: is the search going nowhere? → the task gets marked finished: did something get skipped? Jev engineering does the same thing one level down. the forks that don't need real thought, which file, which tool, keep going or stop, go straight to Jev and come back in under half a second. the big models only ever see the forks that genuinely need a decision. anyone still running one model for everything is paying Opus prices to decide whether a file exists. drop this into Claude Code: "Rebuild my Claude Code setup around this structure: 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: sonnet, effort: medium on each. If an existing subagent is locked to a different model, leave it as is and just list it. In ~/.claude/settings.json, set effortLevel to high and advisorModel to fable. Check for anything disabling the advisor, CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, or anything blocking feature-flag fetches, plus CLAUDE_CODE_EFFORT_LEVEL, which can override subagent effort settings. Report what you find. Don't change any of it yet. Add one line to ~/.claude/CLAUDE.md: check in with 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."show more

To make it easier to migrate your workflows, we've... updated the claude-api skill in Claude Code with Opus 4.7 support. Just say "migrate to Opus 4.7" and it updates model names, prompts, and effort settings for you.show more

Claude Code tip: if Opus 5.5 is already your... main model, Fable 5.1 has been sitting idle this whole time. wire it in with /advisor start it with /advisor fable Opus 5.5 writes every line. Fable 5.1 reads the whole session, every tool call, and says nothing until one of three moments: → a plan gets proposed: is this actually the right move, or just the first one? → the same error comes back twice: is the search stuck, or is this a dead end? → the task gets marked done: what got missed while it was moving fast? Opus 5.5 ships. Fable 5.1 catches what would've shipped broken. Jev engineering makes the same move one layer down: forks that don't need a real thinker, which file, which tool, retry or give up, get routed to Jev and answered in under half a second. the expensive model only ever sees the forks that genuinely split. the tree this runs on: > Opus 5.5, high effort, owns the main session > explorer, medium effort, reads the code > worker, medium effort, edits and runs tests > researcher, medium effort, pulls the docs > Fable 5.1 outside all of it, on call, never writing a line itself drop the tree and this prompt into Claude Code: "Rebuild my Claude Code setup around this tree: 1. Look in ~/.claude/agents and .claude/agents for subagents that already cover explorer, worker and researcher. Draft new ones only for roles that are missing. Set each to model: opus, effort: medium. If an existing subagent is pinned to a different model, list it, don't touch it. 2. Set the main session's effortLevel to high in ~/.claude/settings.json, and set advisorModel to fable. 3. Check for anything disabling the advisor: CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, any variable blocking feature-flag fetches, and CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report what you find. Change nothing yet. 4. Add one line to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before marking a long task done. Show every change as a diff first. Don't touch anything until I say go."show more

jev + sonnet 5.5 is f**king insane. my entire... workflow got 4x faster after adding these 6 lines to CLAUDE.md. [with jev connected, paste this👇] 1. Before you start a Claude worker, ask Jev once to select a host-approved profile with one or two sessions. The profile must specify each session’s model and effort level. If Jev makes no selection, use the host default. 2. The host must check Jev’s selection. The host must set the model and effort before each session starts. Keep these settings fixed during the session. The host controls permissions and approvals. 3. Use Sonnet 5.5 at medium effort for clear coding tasks. Use higher effort for complex reasoning or JSON tasks. Use a second Claude only for independent research or a review that the user requested. 4. Give the second Claude the task, applicable files, limits, and completion requirements. Return its findings and evidence to the lead. 5. Complete the requested work. Ask the user only when you cannot continue without input or before an action that needs approval. Do not add features, tests, files, documentation, refactors, or review rounds that the user did not request. When the work is complete and checked, stop. Report the result. 6. Before you report completion, run a test, build, type check, or command that checks the code change. If no check can run, identify the missing check. Explain why it cannot run. same task. two timers. watch the difference.show more

THIS IS PURE F*CKING PLATINUM Anthropic just shared a... Claude Code setup that stops you from wasting expensive models on work cheaper ones can handle idea: let Sonnet write the code, Haiku handle the exploration, and Opus review the decisions that actually matter you just start Claude Code like this: `claude --model sonnet --advisor opus` here's how it splits: → Sonnet 5 runs the session and writes the code → Haiku 5.5 explores files and docs in parallel → Opus 5.5 stays on call as advisor for the big decisions → you stop burning Opus context on tasks that don't need it Opus only steps in at three moments: → before a plan locks → when the same error hits twice → before calling it done Sonnet builds. Haiku explores. Opus reviews. 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 milliseconds, and the big models only see the ones that split full tree > Sonnet 5 runs the main session and edits code > search maps the repo on Haiku 5.5 > grep finds call sites on Haiku 5.5 > docs pulls the API reference on Haiku 5.5 > Opus 5.5 on call as advisor, reads the full transcript when consulted > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code setup around this tree: 1. Run the main session on Sonnet 5 with Opus 5.5 as advisor. 2. Create three read-only Haiku 5.5 subagents: search (maps the repo), grep (finds call sites), docs (pulls the API reference). 3. Add one rule to CLAUDE.md: consult the advisor before locking a plan, after the same error twice, and before calling a task done. 4. 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, it'll come in handyshow more

Routing for long-horizon coding agents is a big deal.... Not Diamond just announced a model router that works natively with Claude Code. This is huge. It picks the model and reasoning effort before each turn in a session, runs through a privacy-preserving local proxy, and your requests still execute through your own gateway. In their benchmarks, it approximates Opus 4.8 Xhigh quality at 39 to 61 percent lower cost.show more

Claude Code's new dynamic workflow is the real deal.... 🤖 Why it matters: It's not just a chain of prompts — it's an autonomous agent swarm. 1. Set model to Opus 4.8 + reasoning effort /ultracode 2. Claude detects complexity, writes orchestration script on the fly 3. Spawns a parallel fleet of coordinated subagents Operator takeaway: This is the first time I've seen an agent actually decompose and delegate autonomously without a rigid framework. Have you tried it yet? 🚀show more

Smol tip: you don't have to wait for Claude... to finish working before giving it the next task. Type a message and hit Enter to queue it. If you need to edit, ↑ to pull it back into the prompt box.show more

Everyone is dunking on Sonnet 5 for losing to... Opus 4.8 on benchmarks. They're all making the same mistake, judging a teammate by a solo test. Sonnet 5 was never built to win alone. Set the model to Sonnet 5, effort to Ultracode, and any complex task auto-kicks a dynamic workflow where it plans, spawns agents, executes and checks its own work, fast and cheap. When Fable 5 comes back, the setup gets stupid good. Fable 5 decides what to build, Sonnet 5 actually builds it. You stop paying flagship prices to do grunt work.show more

Opus 5.5 works best on 'low' reasoning effort. I... ran some tests as part of a project I'm working on. Opus 5.5 on 'low' reasoning vs. 'max' was at parity on task completion but 12x lower cost! Set 'low' reasoning effort by default and increase it for the hardest problems.show more

THIS IS AN ABSOLUTE GOLDMINE The team at Anthropic... just revealed one of the most effective techniques for Claude Code The core concept: run Sonnet, Haiku 5.5, and Opus 5.5 simultaneously, letting each model focus strictly on what it does best You get higher quality output while dramatically reducing token consumption, since every specific job gets routed to the optimal model To spin up Claude Code with this setup, simply execute: ⁠claude --model sonnet --advisor opus⁠ Here is how the workload is split: > Sonnet 5.5 handles the primary session, writes code, and applies bug fixes > Haiku 5.5 scans the codebase in parallel: performing searches, running grep queries, exploring docs, and auditing diffs > Opus 5.5 acts as an on-demand advisor for critical decisions and approves final code diffs > You stop burning expensive Opus context on routine tasks that don't require high-level reasoning Opus intervenes exclusively during three specific scenarios: > Right before locking in an execution plan > Whenever the exact same error triggers twice in a row > Prior to marking a task as complete Sonnet builds. Haiku scans and explores. Opus reviews JEV engineering applies the exact same principle one layer deeper: routine execution forks that don't need high-level reasoning (determining which file to inspect, which tool to trigger, or whether to retry or stop) are processed by JEV in sub-milliseconds, leaving big models to handle only complex decision splits The full architectural tree: Sonnet 5.5 manages the primary session and modifies code Search maps out the repository structure via Haiku 5.5 Grep locates call references using Haiku 5.5 Docs fetches API specifications through Haiku 5.5 Opus 5.5 serves as an advisor, reading the complete conversation history whenever consulted JEV routes lightning-fast micro-forks in milliseconds Feed this tree structure alongside the prompt below into Claude Code Reconfigure my Claude Code workspace based on this architecture: 1. Run the primary session utilizing Sonnet 5.5, with Opus 5.5 designated as the advisor 2. Set up three read-only Haiku 5.5 subagents: search (maps out the repo), grep (locates call sites), and docs (retrieves API documentation) 3. Insert a single rule into CLAUDE.md: consult the advisor prior to committing to a plan, after encountering an identical error twice, and before marking a task as done 4. Direct rapid, deterministic decisions (tool selections, file paths, retries) through JEV. Show all modifications as a diff first. Do not execute any edits until I grant permission Bookmark this setup: it will become a daily driver in your workflowshow more

Claude Coders: Pair Haiku 5.5 with an Opus advisor... *NOW*. Opus 5.5 checks Haiku's work. Take advantage of the speed and cost-efficiency of Haiku with the intelligence of Opus. Copy this into settings.json (or ask Claude to): {"model":"haiku","advisorModel":"opus"}show more

Gemini 3.6 Flash is available in Antigravity CLI ☄️... Set it via /model which also now has an effort level slider! Recommend using medium effort for most tasks. Give it a try and let us know what you think. 🙏show more

By tomorrow, everyone will be using this: Anthropic just... revealed the ultimate power move for Claude Code The concept: have Opus 5.5 design the master plan as a script, then deploy parallel swarms of the new Haiku 5.5 Massive scale operations with zero wasted Opus compute: the script manages the execution loop so Opus only reviews the final diff Simply boot up Claude Code with these parameters: claude --model opus --effort ultracode Here is the task distribution: -> Opus 5.5 translates your target into a fully runnable workflow script -> Haiku 5.5 scans all files concurrently at 340 tokens/sec to spot candidates -> Sonnet 5.5 applies each patch and validates findings within an isolated workspace -> You eliminate wasting Opus context on dozens of agent log transcripts Opus is involved at only three specific steps: -> writing the initial workflow script before execution -> analyzing verified results once the swarm wraps up -> giving final approval prior to committing any code to git Opus architects | Haiku audits | Sonnet delivers JEV engineering applies the exact same principle a level deeper: logic paths that require no deep reasoning (choosing files, picking tools, handling retries/stops) pass through JEV in milliseconds, leaving heavy models to focus only on complex branches The complete architecture: Opus 5.5 orchestrates the core session and generates workflow.js pipeline() fans out instances of Haiku 5.5 to inspect every file parallel() schema validators eliminate false alarms directly in V8 Sonnet 5.5 applies fixes within dedicated, isolated worktrees verify double-checks all code diffs prior to summary generation Opus 5.5 processes exclusively the results that survived validation JEV routes lightweight micro-decisions in milliseconds Feed this architecture and prompt directly into Claude Code Reconfigure my Claude Code setup following this tree: 1. Execute the primary session using Opus 5.5 with ultracode enabled 2. Assign read-only scanning phases to Haiku 5.5 across all workflows, while routing code modification steps to Sonnet 5.5, running each edit inside its own isolated copy 3. Update CLAUDE.md with a new rule: assign a separate verifier agent to every issue before reporting, and terminate fix loops after two iterations without progress 4. Route fast, deterministic branching (tool selection, path routing, retry logic) via JEV Present every modification as a diff upfront do not execute changes until approved Bookmark this to stay one step aheadshow more