
delost
@thedelost • 5,593 subscribers
cooking at finance & ai
Shorts
Videos

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 error comes back: am I digging in the wrong place? → before "done": what did I miss? Astra reviews. Sol 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 > GPT-6.1 Sol on high runs the main session > explorer reads the code on Luna > worker edits and runs tests on Sol > researcher pulls the docs on Luna > all three on medium > Astra on call as the architect > auto_review checks 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, worker and researcher. > 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, whose only job is reviewing plans, repeated errors and finished work > Skip any that pin a different model and list 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." ↳
delost1,076,218 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." ↳
delost701,333 görüntüleme • 1 ay önce

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: let Opus 5.5 write the plan as a script, and let a swarm of cheaper agents run it. Bigger jobs and way fewer Opus tokens, because the script holds the plan and Opus only sees the final answer. You just launch Claude Code like this: claude --model opus --effort ultracode here's the split: → Opus 5.5 turns your task into a workflow script → Haiku 5.5 agents scan every file in parallel → Sonnet 5.5 agents patch each fix in its own isolated copy → you stop burning Opus context on a hundred agent transcripts Opus only shows up at three moments: → writing the workflow before the run → reading the verified results after it → signing off before anything ships Opus plans. Haiku scans. Sonnet 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 milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the main session and writes the workflow > scan audits every file on Haiku 5.5 > edit patches each fix on Sonnet 5.5 in an isolated copy > verify cross-checks every finding on Sonnet 5.5 > Opus 5.5 reads only what survived verification > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with ultracode on. 2. In every workflow, run read-only scan stages on Haiku 5.5 and edit stages on Sonnet 5.5, each edit in its own isolated copy. 3. Add one rule to CLAUDE.md: every finding gets an independent verifier agent before it's reported, and fix loops stop after two rounds with no progress. 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 handy.
delost401,481 görüntüleme • 24 gün önce

THIS IS ACTUAL F*CKING GOLD Anthropic just shared one of the best tricks for Claude Code. The idea: run Sonnet, Haiku and Opus 5.5 together, each one doing only the job it's best at. Opus-level judgment on every big call, without paying Opus rates for every routine turn. You just launch Claude Code like this: claude --model sonnet --advisor opus here's the split: → Sonnet 5.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 calls → you stop spending Opus on work that doesn't need it Opus only steps in at three moments: → before a plan locks → when the same error shows up 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 the full tree > Sonnet 5.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 whole transcript when consulted > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Sonnet 5.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, you'll use this every single day.
delost320,430 görüntüleme • 25 gün önce

THIS IS PURE F*CKING GOLD Anthropic just shared one of the best tricks for Claude Code. The idea: run Sonnet, Haiku and Opus 5.5 at the same time, each one doing only what it's best at. Better results and way fewer tokens, because every task lands on the right model. 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 the 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 handy.
delost316,202 görüntüleme • 27 gün önce

THIS IS F*CKING INSANE Anthropic turned Agent Skills into an open spec and GitHub filled up with ready-made Claude Code teams for free one of these repos alone ships 135 agents, 35 skills, 42 commands, 176+ plugins and 20 hooks. another hands you 100+ specialized subagents. none of it costs anything 10 GitHub projects you should open first: 01 wshobson/agents → a plugin marketplace that installs the same agents into Claude Code, Codex, Cursor and Copilot, so your setup survives switching tools 02 VoltAgent/awesome-claude-code-subagents → 100+ specialized subagents covering most of what a normal engineering week throws at you 03 rohitg00/awesome-claude-code-toolkit → 135 agents, 35 curated skills, 42 commands, 176+ plugins, 20 hooks and 14 MCP configs in one place 04 anthropics/skills → the official Agent Skills repo. start here to see the shape of a working SKILL.md before you copy anyone else's 05 netresearch/claude-code-marketplace → curated skills on an open standard, portable across Claude Code, Cursor, Copilot, Codex, Gemini CLI and 30+ other agents 06 disler/claude-code-hooks-mastery → the hooks reference. this is where you learn to make the agent stop on your rules instead of stopping to ask you 07 karanb192/claude-code-hooks → an installable hooks marketplace split into safety, cost, observability and productivity 08 affaan-m/claude-swarm → multi-agent orchestration that decomposes the task, coordinates the agents and shows the whole run in a terminal UI 09 am-will/swarms → orchestration shipped as skills, so the coordination loads only when the job actually calls for it 10 eugeniughelbur/obsidian-second-brain → persistent memory as plain markdown in an Obsidian vault, shared across Claude Code, Codex and six other agents give the first team a job with an obvious finish line: one reviewed PR, one researched brief, one failing test turned green then look at how much of that output you actually kept, and what it cost to produce. a bigger roster earns its place when it moves that number the download is free. paying four agents to repeat the same investigation is not save this before you spend another weekend building a config that already exists the article below shows how to keep context small, reuse finished work and contain retries, so more of your budget reaches the finished result ↓
delost96,871 görüntüleme • 14 gün önce

THIS IS AN ACTUAL F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: run Sonnet, Haiku 5.5 and Opus 5.5 at once, each one doing only the job it's best at. Better results and way fewer tokens, because every task lands on the right model. You just launch Claude Code like this: claude --model sonnet --advisor opus here's the split: → Sonnet 5.5 runs the session, writes the code and applies the fixes → Haiku 5.5 swarms the repo in parallel: search, grep and diff audits → Opus 5.5 stays on call as advisor for the big calls and signs off on the diff → you stop burning Opus context on work that doesn't need it Opus only steps in at three moments: → before a plan locks → when the same error shows up twice → before calling it done Sonnet builds. Haiku swarms. 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 the full tree > Sonnet 5.5 runs the main session and coordinates the work > search maps the repo on Haiku 5.5, read-only > grep finds call sites on Haiku 5.5 in its own context > audit checks the diff on Haiku 5.5 in a throwaway worktree > Opus 5.5 on call as advisor, reviews the synthesized diff before sign-off > 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.5 with Opus 5.5 as advisor. 2. Create three Haiku 5.5 subagents in .claude/agents: search (maps the repo), grep (finds call sites), audit (checks the diff). 3. Set isolation: worktree on audit so its checks never touch my working branch. 4. Add one rule to CLAUDE.md: delegate every repo search and test run to the Haiku 5.5 subagents to keep the main context small. 5. Route fast deterministic forks (tool choice, path selection, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳
delost105,386 görüntüleme • 19 gün önce

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

a 25-delta put trades at 22% implied vol. the call at the same distance trades at 15% same index, same expiry, same distance from the money. 7 points apart black-scholes says that gap shouldn't exist the model assumes one volatility number for every strike σ constant across strikes and expiries. one distribution, lognormal returns, flat surface plot the real chain and you don't get a flat line you get a surface. tilted, curved, repricing every second that tilt has a name: skew and it's the closest thing markets have to a live fear gauge the reason it exists is structural, not a pricing error crashes are faster and deeper than rallies. returns have fat left tails so protection below the market costs more than the model says, because the model's normal distribution never priced the tail correctly this wasn't always true before october 1987 the surface was roughly flat. the crash rewrote it permanently one event taught the entire options market that the left tail is real, and the skew has never gone away since the measurement is simple: skew = IV(25-delta put) − IV(25-delta call) on the example above that's 22 − 15 = 7 points when that spread widens, demand for downside protection is rising. someone is paying up to hedge when it flattens, the bid for protection is fading same index level, same price on your chart, two completely different states of institutional fear the chart shows where price is. the surface shows what people are paying to be wrong and the shape carries more than direction steepness tells you how much tail risk is priced term structure tells you whether the fear is about this week or this quarter curvature tells you how much the market disagrees with its own base case retail sees one implied vol number on the option they're about to buy a desk sees a surface and trades the difference between its shape and what that shape usually looks like every input is public. the chain lists IV at every strike and expiry strike on one axis, expiry on another, IV on the third. the surface builds itself black-scholes won a nobel for a formula the market has been visibly disagreeing with since 1987 the disagreement is the signal full breakdown in the article below
delost89,999 görüntüleme • 3 ay önce

a quant who started as a technical trader explained what changed everything for him he stopped trying to predict where price goes he started measuring the probability of each market state and betting only when the math was asymmetric that shift took him from drawing trendlines to writing models at 22 the realization was simple but brutal: technical analysis gives you a narrative quantitative analysis gives you a number one feels right the other is testable, repeatable, and either works or doesn't across 10,000 trades the setup on his desk tells the whole story no TradingView. no candlestick charts. just code, data, and a terminal he didn't go to MIT he didn't intern at Goldman he learned Python, statistics, and probability theory on his own and built something that actually worked > the math: free in any stats textbook > the data: free on Yahoo Finance, FRED, exchange APIs > the code: Python, 200 lines, running on a laptop > the barrier: not intelligence. just knowing this path exists most people spend years staring at indicators from the 1970s wondering why they can't find consistency the answer was never a better indicator it was a completely different framework one that treats trading as a math problem, not a prediction game full breakdown in the video below
delost113,459 görüntüleme • 4 ay önce

THIS IS A PURE F*CKING GOLD Anthropic made Agent Skills an open spec and GitHub filled up with entire Claude Code engineering teams for free one repo ships 380 skills, 30+ agents and 70+ commands. another one watches your spend in real time so the team you just installed doesn't quietly eat your weekly limit. nobody is charging for any of it 10 GitHub repos worth opening tonight: 01 wshobson/agents → a plugin marketplace that installs the same agents into Claude Code, Codex, Cursor and Copilot, so your setup survives switching tools 02 subinium/awesome-claude-code → a curated list of tools, skills, plugins and MCP servers. the map before you start downloading 03 rohitg00/awesome-claude-code-toolkit → 135 agents, 35 curated skills, 42 commands, 176+ plugins, 20 hooks and 14 MCP configs in one place 04 anthropics/skills → the official Agent Skills repo. start here to see the shape of a working SKILL.md before you copy anyone else's 05 alirezarezvani/claude-skills → 380+ skills, 30+ agents and 70+ commands, portable to Codex, Gemini CLI, Cursor and eight more agents 06 disler/claude-code-hooks-mastery → the hooks reference. this is where you learn to make the agent stop on your rules instead of stopping to ask you 07 muhammadusmangm/claude-code-best-practices → setup, CLAUDE.md templates, multi-agent patterns and cost optimization, written as a wiki instead of a dump 08 Maciek-roboblog/Claude-Code-Usage-Monitor → real-time usage monitor with predictions and warnings, so you find the wall before you hit it 09 Scorpio3310/claude-code-usage-statusline → daily and monthly spend, 5h and weekly limit meters, per-model quotas, all local, no API key 10 eugeniughelbur/obsidian-second-brain → persistent memory as plain markdown in an Obsidian vault, shared across Claude Code, Codex and six other agents install the statusline before you install the agents. you want to watch what the fleet costs while it runs, not find out on Sunday when the weekly meter is already flat then hand the first team one job with an obvious finish line: one reviewed PR, one brief, one red test turned green keep the pieces that changed the result and delete the rest the same day. a config you did not write is a config you cannot debug at 2am the repos cost nothing. four agents repeating the same investigation is where the money actually goes save this one, the list only gets longer from here the article below shows how to keep context small, reuse finished work and contain retries, so more of your budget reaches the finished result ↓
delost12,765 görüntüleme • 13 gün önce

THIS IS STRAIGHT F*CKING GOLD Anthropic just shared one of the best tricks for Claude Code. The idea: one knob with five settings, and almost nobody ever moves it. Every routine turn runs at the same effort as your hardest decision, and you pay for thinking you never read. You just start Claude Code like this: claude --model opus --effort low here's the split: → low runs the routine turns, renames, imports, fixtures, formatting → /effort xhigh the moment an actual decision shows up → every subagent carries its own effort line in its frontmatter → you stop paying Opus 5.5 to think about which file to open you only climb the ladder at three moments: → before a plan that touches a lot of files → when the same bug survives two fixes → before a release you cannot roll back Low for the routine. High for the fork. Max for the rescue. 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 with zero thinking tokens, and the big models only see the ones that split the full tree > Opus 5.5 runs the main session at low effort > /effort xhigh the moment a real decision shows up, then back down > search runs on Haiku 5.5 with effort: low in its frontmatter > review runs on Sonnet 5.5 with effort: high in its frontmatter > every skill carries its own effort line, so the level follows the task > JEV routes micro-forks in milliseconds and thinks about none of them paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 at low effort. 2. Set effort: low on every read-only subagent and effort: high on the review subagent. 3. Add one rule to CLAUDE.md: stay at low, climb to xhigh only before a multi-file plan, after the same error twice, and before an irreversible change, then drop back. 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 handy.
delost19,355 görüntüleme • 22 gün önce

in 2019 my grandfather sold every stock he owned not because he saw a crash coming because he did the math on something Wall Street hides from you on purpose a 10-year Treasury pays 4.3% right now guaranteed. by the US government. twice a year. for a decade no earnings misses. no CEO scandal. no rug pull just a fixed schedule of cash arriving in your account every 6 months until 2034 $100k in Treasuries pays $4,300 a year in coupons alone $500k pays $21,500 $1M pays $43,000 that's not a return you have to trade for it's a return the Treasury owes you by law your broker doesn't mention it because they make nothing when you buy one no commission, no advisory fee, no reason to call meanwhile the wealthiest families in America have quietly built Treasury ladders for 200 years stagger maturities across 1, 2, 5, 10, 20 years coupons arrive every month liquidity every year it's not sexy it's not a 10x it's the thing that pays you while you sleep and never asks anything back my grandfather figured this out at 68 retired two years later watch the video. the professor explains the whole ladder in 82 seconds
delost80,689 görüntüleme • 4 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." ↳
delost28,222 görüntüleme • 1 ay önce

this model doesn't predict where the S&P 500 will go it predicts when the market's own velocity is about to collapse Z(x,y) = F(β, α, τ, ∇τ; x, y, t) one equation. four parameters. a 3D surface that maps how price momentum evolves across time and space β is drift velocity: μ/σ, the ratio of expected return to volatility when β is high the market is moving with conviction when β decays toward zero the trend is losing energy before the chart shows any sign of it α measures how fast that velocity is changing τ is the time structure of the regime ∇τ is the gradient, the rate at which the regime itself is shifting the 3D surface on screen is not decoration the red peaks are where momentum is concentrated and unstable the blue basin is where the system is calm and mean-reverting the yellow marker is where the S&P sat at the moment of the snapshot the model's output: position sizing optimization not buy or sell. how much exposure to hold given the current position on that surface the bottom chart shows it: blue line is the model, white line is buy & hold same asset, same period, different sizing at every point based on where the dynamics equation said the market was > time dynamics models: rooted in physics, applied to finance since the 1990s > drift-to-volatility ratio: standard risk metric at Two Sigma, AQR, Man Group > this exact framework: free, public, 60 seconds in this video > what retail uses instead: lagging indicators that measure the past, not the velocity of the present retail asks "is the market going up or down?" this model asks "how fast is the market's own energy decaying and where on the surface are we right now?" completely different question. completely different result full breakdown in the video below
delost72,579 görüntüleme • 4 ay önce

holy sh*t. Official Anthropic tip for Claude Code: stop burning Opus 5.5 context on tasks Haiku 5.5 can swarm, while Sonnet 5 builds put the architect on call with /advisor claude --model sonnet --advisor opus Sonnet 5 drives the primary session on high effort, writing diffs and running test suites Haiku 5.5 subagents swarm the repo in parallel, handling file discovery and spec docs lookup Opus 5.5 stays on call in the background as the advisor, only stepping in at three critical moments: → before a plan locks: does the implementation plan miss auth invariants or schema contracts? → when a test breaks twice: are we fixing the root cause or falling into a recursive rabbit hole? → before calling done: did the full diff introduce hidden regressions or break pre-flight rules? Opus 5.5 reviews. Sonnet 5 builds. Haiku 5.5 swarms 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) resolve in milliseconds, so the frontier models only wake up when execution paths actually diverge Plan on high. Delegate to Haiku. Keep Opus on call. - the full advisor setup > Opus 5.5 on call reads the full session transcript and catches deep architectural traps > Sonnet 5 lead drives edits, writes core logic, and executes test harnesses > Haiku 5.5 subagents swarm grep scans, file discovery, and API docs in parallel > subagents inherit the advisor automatically, no extra config > toggling the advisor mid-session never invalidates the prompt cache paste the setup and this prompt into Claude Code below: "Configure my Claude Code workspace for hierarchical advisor orchestration: 1. Audit ~/.claude/settings.json and project config for model roles fitting lead, subagents, and advisor: > Pin main session model: sonnet with effortLevel: high for primary execution > Pin subagents to model: haiku in ~/.claude/agents for parallel file discovery and docs retrieval > Pin advisorModel: opus for strategic review 2. Draft read-only subagent definitions in ~/.claude/agents: > file-search and docs-lookup, model: haiku, read-only tools > return structured summaries and docs snippets only, never edit > skip any that already exist and list them 3. Configure advisor consultation checkpoints in ~/.claude/CLAUDE.md: > Consult the advisor before finalizing multi-file architecture plans > Consult the advisor when the same test or compiler error fails twice > Consult the advisor for a diff audit before declaring tasks complete or staging git commits 4. Find anything that would override this setup: > CLAUDE_CODE_SUBAGENT_MODEL, CLAUDE_CODE_DISABLE_ADVISOR_TOOL, CLAUDE_CODE_EFFORT_LEVEL > Report it, change nothing Show every configuration diff first. Do not apply edits until confirmed" ↳
delost17,319 görüntüleme • 29 gün önce

Bridgewater doesn't have 500 positions they have 5 exposures that explain 78% of everything those 500 positions do this video shows what that looks like in 3D PCA Risk-Mode Trajectory. three axes: PC1, PC2, PC3 each one is a principal component extracted from the return matrix of the entire market PC1 is broad market direction. it alone explains roughly 40% of all stock movement PC2 separates growth from value. another 15% PC3 captures rate sensitivity. another 10% three invisible forces. 65% of the variance in every stock you've ever traded the dot moving through that 3D space is where the market is right now when the dot drifts toward a corner, the market is concentrating into one regime when it sits in the center, forces are balanced and directional trades are noise quant desks don't watch that dot for fun. they use its position to size every trade in the book if PC1 is dominating, stock picking is pointless because everything moves together if PC2 is leading, the value vs growth rotation is the only trade that matters if PC3 spikes, interest rate sensitivity is driving everything and your "stock pick" is really a rate bet you didn't know you made > PCA: Karl Pearson, 1901 > used at Bridgewater, AQR, Two Sigma for factor decomposition since the 1990s > this visualization: free, public, 29 seconds > scipy builds PCA in 3 lines of Python retail analyzes 500 tickers and thinks they're making 500 decisions quant desks decompose the same 500 into 5 forces and make 5 decisions one is complexity. the other is the math that simplifies it full breakdown in the video below
delost49,400 görüntüleme • 4 ay önce

this is pure f*cking treasure 10 GitHub projects that put Jev between your agent and every decision your agent should stop paying a frontier model to answer yes or no ROUTE THE WORK 01 jev-router > 02 jcm-router > 03 jev-agent-skill-router > GUARD EVERY ACTION 04 pi-heed > 05 fx > 06 Foreman > SCORE WHAT MATTERS 07 LlamaIndex Jev > 08 citation-verifier > PUT IT TO WORK 09 yoshi > 10 mastra-jev-moderation > the loop: your agent hits a fork > Jev answers with a probability > your code decides what that number allows > the agent moves on 3 builds I'd explore: coding agent: jev-router > fx > Foreman > yoshi support desk: jev-agent-skill-router > mastra-jev-moderation > LlamaIndex Jev research: jcm-router > pi-heed > citation-verifier save this, then build a decision layer for your agents ⭣
delost16,024 görüntüleme • 1 ay önce