Squish Lab

squishy things i make with claude. one prompt each.

[Squish Lab @squishlab_ai]

THIS IS A PURE F*CKING GOLDMINE

48 files went in. 6 lines came back. that's all Opus ever saw

your Claude Code session gets dumber the longer it runs, and it's not the model. it's the context window filling up with files it already finished reading

this board fixes it with one setting: every subagent gets its own context window

the task: find every auth call site

you launch it like this:

claude --model opus # subagents: own context window

here's the split:
→ Opus 5.5 runs the main session, plans and delegates, and never reads a raw file
→ Subagent A, Haiku 5.5: reads all 48 files in src/auth/
→ Subagent B, Sonnet 5.5: refactors 31 call sites in src/api/
→ Subagent C, Haiku 5.5: runs 212 tests in tests/
→ all 3 run at once, each in its own window, and only a short summary goes back to Opus

the part most people get wrong: they think subagents are about speed.
they're about what stays out of your main session. every file a subagent reads dies with its context. Opus gets the conclusion and keeps a clean head for the next decision

one slice per subagent. auth, api, tests. no two agents read the same folder

one catch worth knowing: a summary can drop the detail you needed. make every subagent return file and line for each finding, so Opus can open exactly one file instead of all 48

Haiku reads. Sonnet patches. Opus remembers only what matters.

JEV engineering is the same move one layer down: [X] forks this run (which folder, which subagent, summarize or dig deeper) resolved in code at [0.XX] sharpness, and only the split ones ever reach Opus

the full tree
> Opus 5.5 runs the main session, plans and delegates, context kept small
> a delegator gives each subagent one slice of the repo
> Haiku 5.5 reads src/auth/, Sonnet 5.5 patches src/api/, Haiku 5.5 runs tests/
> each subagent works in its own context window, all 3 in parallel
> only short summaries with file and line come back
> Opus never reads raw files, so its window stays clean for the next call

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 for planning, delegation and decisions only.
2. Any task that reads more than a few files goes to a subagent with its own context window.
3. Give each subagent one slice of the repo. No two subagents read the same folder.
4. Reading and tests go to Haiku 5.5, refactors go to Sonnet 5.5.
5. Every subagent returns a short summary with file and line for each finding. Raw files and logs never enter the main session.

Route deterministic forks (which folder, which subagent, summarize or dig deeper) through JEV.

Show me every change as a diff first. No edits until I say go."

↳ https://t.co/E7FjDocTpU

save it, it'll come in handy.

[mirku @mirku21]

https://t.co/PaAzxlyrsH

[Squish Lab @squishlab_ai]

@bubosees Opus only merges after tests pass, so it can refuse a branch

[Squish Lab @squishlab_ai]

THIS IS A PURE F*CKING GOLDMINE

run 3 Claude Code agents on one repo and they will step on each other's files. this setup puts each one in its own worktree: 3 agents, 3 branches, 0 conflicts, main never touched

the task on the board: add token refresh to auth.ts

you launch it like this:

claude --model sonnet # agents: isolation: worktree

here's the split:
→ Sonnet 5.5 runs the main session, splits the task and spawns the agents
→ the splitter cuts it into 3 slices with 0 file overlap: auth.ts, auth.test.ts, README.md
→ Agent A, Sonnet 5.5: the token refresh refactor in wt/a, branch feat/token
→ Agent B, Haiku 5.5: writes 8 tests in wt/b, branch feat/tests, all green
→ Agent C, Haiku 5.5: updates the README in wt/c, branch feat/docs
→ Opus 5.5 reads each diff, runs the tests and merges one branch at a time

the part most people get wrong: they run agents in parallel on the same checkout.
two agents open the same file, one overwrites the other, and you spend the saved time untangling it. a worktree gives every agent its own copy of the repo, so there's nothing to collide with

the other part: splitting by task isn't enough, you split by file. 0 overlap on the splitter is what makes the merge boring

and Opus never writes a line here. it sits in .claude/agents as the merge reviewer and only reads diffs

one catch worth knowing: worktrees stop collisions inside files, not inside logic. if slice A changes a function slice B depends on, the tests are what catch it, so Opus runs them before every merge

Sonnet builds. Haiku checks. Opus merges.

JEV engineering is the same move one layer down: [X] forks this run (which slice, which agent, merge or retry) resolved in code at [0.XX] sharpness, and only the split ones ever reach Opus

the full tree
> Sonnet 5.5 runs the main session, splits the work, spawns agents
> a splitter cuts the task by file, 0 overlap between slices
> every agent gets its own worktree and its own branch
> Sonnet 5.5 writes the code, Haiku 5.5 writes tests and docs
> Opus 5.5 reviews each diff, runs tests, merges one branch at a time
> main stays clean the whole run, conflicts stay at 0

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. It splits each task and spawns agents.
2. Split every task by file, never by topic. No two agents touch the same file.
3. Every agent runs with isolation: worktree, on its own branch. Main is never edited directly.
4. Code slices go to Sonnet 5.5, tests and docs go to Haiku 5.5.
5. Add an Opus 5.5 merge reviewer in .claude/agents: it reads each diff, runs the tests and merges one branch at a time.

Route deterministic forks (slice choice, agent choice, merge or retry) through JEV.

Show me every change as a diff first. No edits until I say go."

↳ https://t.co/E7FjDoclAm

save it, it'll come in handy.

[mirku @mirku21]

https://t.co/PaAzxlyrsH

[Squish Lab @squishlab_ai]

@0xVorzen Agreed, the worktree + zero file overlap split is the cleanest part.

[Squish Lab @squishlab_ai]

@Klonzu Short English reply: Worktrees fixed the same chaos for me too.

[Squish Lab @squishlab_ai]

Not always. Opus only merges after reviewing the diff and confirming the tests pass

[Squish Lab @squishlab_ai]

@stewy0x Love this. Adding a 'supersedes' note in decisions.md stops old plans from looking valid later.

[Squish Lab @squishlab_ai]

@kirisando This is the most realistic AI group chat I've seen. The rate limit cliffhanger is perfect

[Squish Lab @squishlab_ai]

@Firrti Really impressive work. The interactive breakdown into thousands of pieces is next level

[Squish Lab @squishlab_ai]

@_Aquarelle History rhymes: the technique that enabled the PC clone industry, fully automated

[Squish Lab @squishlab_ai]

I'M NOT SURE THIS SHOULD BE LEGAL

an Opus 5.5 board just rebuilt an app it never saw the code of. 49 of 50 inputs match. 0 lines copied

and it didn't take the agent's word for it. it counted

the loop comes from Skunzu's reverse engineering article: watch, spec, build, verify

agent one studies the app and writes down what it does
agent two only gets that write-up and builds from zero
a wall between them lets behavior through and nothing else

two functions run the whole thing:

def watch(app):
trace = rea.observe(app)
return opus.describe(trace)

def rebuild(spec):
return opus.write(spec)

set it up in 4 steps:
1. npx rea-agents setup. your agent gets a disassembler over MCP, running on your machine. tool results still go to your model provider
2. add a house rule: each claim is marked observation, inference or unknown, with the file and call site
3. effort: medium to move around, high to annotate, max when the code is obfuscated
4. feed both builds the same 50 inputs: 30 normal, 10 edge, 10 malformed

then watch three things:
→ the match rate. the harness counts, the agent doesn't get a vote
→ every "unknown" in the spec. that's an honest gap, not a guess
→ the copy

[Skunzu @skunzu]

https://t.co/9tFdtAZjqj

[Squish Lab @squishlab_ai]

@HashItOut_ Yeah, that 1 miss is the most useful part. Shows whether the gap is in observation or in the rebuild

[Squish Lab @squishlab_ai]

@0x_cognit True Would be interesting to see how it holds up on inputs the watcher never triggered

[Squish Lab @squishlab_ai]

@coolerwave Yeah, rare win. Mitigation being ready before the full advisory made it much less painful

[Squish Lab @squishlab_ai]

@andreysuperior The oracle checks after every part are genius. Zero errors on a full folding hinge is wild

[Squish Lab @squishlab_ai]

@alxqwrk Endless chat Guilty Starting a new one now, thanks

[Squish Lab @squishlab_ai]

Physics class made pressure feel like algebra.

So I built a hydraulic press you can squish things with. Pump the handle, look inside, and watch one hand turn into 12 tonnes on a gummy bear.

Made with Opus 5.5

[Elvar @elvar_official]

https://t.co/NAgH1EYziQ

[Squish Lab @squishlab_ai]

This is getting out of hand

Anthropic's monorepo now lands 30,000+ code changes a day. In May it was ~2,500

No human team reads 30,000 diffs a day. Here's how Claude reviews them:

Several agents hunt for bugs at the same time
A separate group votes on every finding
A bug only gets posted if enough of them agree it's real
Findings that are only about style or cleanup get dropped

Code owners write a REVIEW.md that says what failure looks like in their part of the code

docs: "it lies"
config: "it misroutes"
cap the nits, list paths to skip, ask for file + line as evidence

Then risk decides how many humans look:

→ low risk: 0 approvals once checks are green
→ medium: 1 person
→ high: 2 people

The numbers on internal PRs:

→ 65% → 78% pass after 1 review + fix round
→ 8.9% → 1.5% need 5+ rounds

And in the Claude Code repo, merged PRs more than doubled from June to September while the share that got reverted fell 40%+

Claude already writes ~90% of Claude Code's own code. Now it reviews it too

The real win isn't the speed. It's keeping humans only on the changes that can actually hurt

Bookmark this before your next PR

[Squish Lab @squishlab_ai]

@Klonzu exactly. Sonnet writes, Haiku greps, Opus just looks disappointed at the diff

[Squish Lab @squishlab_ai]

THIS IS AN ACTUAL F*CKING GOLDMINE

it's right in the Claude Code docs and almost nobody uses it

The idea: run Sonnet 5.5, Haiku 5.5 and Opus 5.5 at once, each doing only what it's best at

Better results and way fewer tokens: every task lands on the right model

You just start Claude Code like this:

CLAUDE_CODE_SUBAGENT_MODEL=haiku claude --model sonnet --advisor opus

here's how it splits:

→ Sonnet 5.5 runs the main session, writes the code, and applies fixes
→ Haiku 5.5 subagents search the repo, grep call sites and run tests at 0.05x Sonnet's price
→ Opus 5.5 sits on call as advisor and checks the work, never touches the keyboard
→ you stop burning Opus on routine tasks and stop flooding the main session with raw logs

Opus only steps in at 3 moments:

→ before a plan locks
→ when the same error hits twice
→ before calling it done (reviews the git diff)

Sonnet builds, Haiku searches, Opus checks

the full tree
> Sonnet 5.5 runs the main session and writes the code
> search maps the repo on Haiku 5.5 (read-only)
> grep finds call sites on Haiku 5.5 (read-only, own context)
> audit checks diffs on Haiku 5.5 (isolation: worktree)
> Opus 5.5 as advisor reviews the plan and the final diff

one catch: the env var is only a default. an agent's own model: field beats it, so write model: haiku into each agent file

paste the tree and this prompt into Claude Code ↓

"Rebuild my Claude Code setup around this tree:
1. Main session on Sonnet 5.5, Opus 5.5 as advisor
2. Create 3 subagents in .claude/agents/, each with model: haiku in the frontmatter: search (read-only, maps the repo), grep (read-only, finds call sites), audit (runs diff checks)
3. Set isolation: worktree on audit so it never touches my working branch
4. Add to CLAUDE.md: delegate all repo searches and test runs to the Haiku subagents. Consult the advisor only before a plan locks, after the same error twice, and before calling a task done
Show me every change as a diff first. No edits until I say go"

save it, it'll come in handy