Hoodie

• Content creator | AI researcher

[Hoodie @HoodieFade_]

https://t.co/ZIC7Xf20b4

[Hoodie @HoodieFade_]

@thegreatest_sv Magic outside Hogwarts is banned, didn't you know? What kind of visual sorcery is this in the terminal?😁

[Hoodie @HoodieFade_]

this is pure f*cking insane

Official OpenAI tip for Codex: stop running Astra on every turn when GPT-6.1 Sol can ship the diffs

The idea: put Astra on call as an architect agent, and let Sol do the heavy lifting in parallel

Massive reasoning sweeps with zero Astra burn: Sol writes the code and Astra only steps in for critical architecture checkpoints

You just launch Codex like this:

codex --model gpt-6.1-sol --architect gpt-6-astra

here's the split:

→ GPT-6.1 Sol runs the primary session on high reasoning effort and writes clean diffs
→ the fast Luna model scans repository files and pulls documentation in parallel
→ flagship Astra stays on call in the background as the lead system architect
→ you stop burning expensive Astra context on running routine terminal commands

Astra only steps in at three moments:

→ before locking a high-level plan: is this the right architectural approach?
→ when the same error hits twice: are we digging in the wrong place or just hiding the bug?
→ before calling "done": what hidden regressions and edge cases did we overlook?

Sol builds · Luna explores · Astra reviews

Deterministic routing executes one layer down: mechanical forks that need no reasoning (path selection, file grepping, retry loops) resolve in milliseconds, so frontier reasoning models only wake up when architectural paths actually diverge

the full tree

> GPT-6.1 Sol on high reasoning effort runs the primary session and executes tests
> explorer subagent on Luna inspects code without bloating context
> researcher subagent on Luna fetches API specs in milliseconds
> Astra on high effort stays on call as the architect through AGENTS.md
> auto_review module automatically blocks merge approval without architect sign-off

paste the tree and this prompt into Codex ↓

"Rebuild my Codex setup around this tree:
• Run the primary session on GPT-6.1 Sol with reasoning_effort set to high
• Create two read-only subagents on Luna in ~/.codex/agents: explorer for code search and researcher for API docs
• Add an architect agent on GPT-6 Astra whose sole job is reviewing multi-file plans and repeated errors
• Add one rule to AGENTS.md: spawn the architect before any large architectural plan, after two identical test failures, and before calling a task done
Show every change as a diff first. No edits until I say go"

https://t.co/Q21VcgLYw2

save it, it'll come in handy

[Hoodie @HoodieFade_]

@Bober_smart You're an artist who paints rain, lol

[Hoodie @HoodieFade_]

this is pure f*cking insane

Official OpenAI tip for Codex: stop running Astra on every turn when GPT-6.1 Sol can ship the diffs

The idea: put Astra on call as an architect agent, and let Sol do the heavy lifting in parallel

Massive reasoning sweeps with zero Astra burn: Sol writes the code and Astra only steps in for critical architecture checkpoints

You just launch Codex like this:

codex --model gpt-6.1-sol --architect gpt-6-astra

here's the split:

→ GPT-6.1 Sol runs the primary session on high reasoning effort and writes clean diffs
→ the fast Luna model scans repository files and pulls documentation in parallel
→ flagship Astra stays on call in the background as the lead system architect
→ you stop burning expensive Astra context on running routine terminal commands

Astra only steps in at three moments:

→ before locking a high-level plan: is this the right architectural approach?
→ when the same error hits twice: are we digging in the wrong place or just hiding the bug?
→ before calling "done": what hidden regressions and edge cases did we overlook?

Sol builds · Luna explores · Astra reviews

Deterministic routing executes one layer down: mechanical forks that need no reasoning (path selection, file grepping, retry loops) resolve in milliseconds, so frontier reasoning models only wake up when architectural paths actually diverge

the full tree

> GPT-6.1 Sol on high reasoning effort runs the primary session and executes tests
> explorer subagent on Luna inspects code without bloating context
> researcher subagent on Luna fetches API specs in milliseconds
> Astra on high effort stays on call as the architect through AGENTS.md
> auto_review module automatically blocks merge approval without architect sign-off

paste the tree and this prompt into Codex ↓

"Rebuild my Codex setup around this tree:
• Run the primary session on GPT-6.1 Sol with reasoning_effort set to high
• Create two read-only subagents on Luna in ~/.codex/agents: explorer for code search and researcher for API docs
• Add an architect agent on GPT-6 Astra whose sole job is reviewing multi-file plans and repeated errors
• Add one rule to AGENTS.md: spawn the architect before any large architectural plan, after two identical test failures, and before calling a task done
Show every change as a diff first. No edits until I say go"

https://t.co/Q21VcgLYw2

save it, it'll come in handy

[Hoodie @HoodieFade_]

https://t.co/ZIC7Xf20b4

[Hoodie @HoodieFade_]

THIS IS A PURE F*CKING GOLDMINE

Official Anthropic tip for Claude Code: stop running single-agent bottlenecks when agent teams can swarm your codebase in parallel

The idea: spawn a full team of Claudes inside your terminal, each with their own context window, mailbox, and task locks

Autonomous development with zero waiting queues: the lead assigns tickets, teammates code in split panes, and the adversary attacks contracts before merge

You just launch Claude Code like this:

claude --teammate-mode auto

here's the split:

→ Team Lead on Opus 5.5 creates the task backlog and synthesizes final pull requests
→ Teammate-UX and Teammate-Backend write client and server logic in isolated contexts
→ Teammate-Adversary on Fable attacks schema contracts and runs security audits before merge
→ all teammates communicate directly over peer-to-peer IPC mailboxes in ~/.claude/teams/ with zero lead overhead

The lead only steps in at three moments:

→ shaping the initial architecture and scoping tasks into tasks.json
→ auto-approving implementation plans from workers without stalling the session
→ signing off on the final merge after the adversary confirms zero regressions

Lead coordinates · Teammates build · Adversary attacks

Collision control executes one layer down: tasks.json manages file mutex locks in milliseconds, so agents self-claim tickets over atomic locks and never overwrite each other's code

the full tree

> launch sessions with the --teammate-mode auto flag in tmux or iTerm2 split panes
> CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 enables autonomous agent teams
> tasks.json manages real-time ticket queues and dependency unblocking
> local inboxes/{agent}.json mailboxes handle direct peer-to-peer messaging
> the TaskCompleted hook blocks ticket completion until security sign-off passes

paste the tree and this prompt into Claude Code ↓

"Rebuild my Claude Code setup around this tree:
• Enable agent teams in ~/.claude/settings.json via CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 and set teammateMode to auto
• Configure three dedicated teammates in .claude/agents/: ux-engineer on Sonnet, backend-engineer on Sonnet, and security-adversary on Fable
• Add atomic file-locking rules to tasks.json so parallel workers never claim the same module simultaneously
• Add one rule to CLAUDE.md: no task can be marked completed without explicit sign-off from the security-adversary teammate
Show every change as a diff first, no edits until I say go"

https://t.co/jYA0Qulvla

save it, it'll come in handy

[Hoodie @HoodieFade_]

Nicely broken down. Especially loved that the writer doesn't even start if the retrieval is empty - in production, that's a real pain when the model starts confidently making things up from semi-relevant chunks. Two Jev calls + hard abstain look like a sane way to both save tokens and cut down on hallucinations.

[Hoodie @HoodieFade_]

@Yarilo7brigada Cool that you didn't just spam agents, but actually separated the writers from the source checkers. When verification is cheaper and simpler, the system actually starts working instead of just bullshitting eloquently. And dumping straight into Obsidian is smart, too.

[Hoodie @HoodieFade_]

Damn, that's literally me. Always buying things in bulk and then looking at the library thinking "well, why." Awesome that you didn't grab anything else and actually sat down and made a plan out of what you already have. Good luck with those 1-2 hours, will be interesting to see how it goes.

[Hoodie @HoodieFade_]

@Nezukoa4 That is exactly what hooks you. Security is no longer hanging somewhere at the end, but just a prerequisite to move forward, a completely different working rhythm. Thanks for highlighting it.

[Hoodie @HoodieFade_]

THIS IS A PURE F*CKING GOLDMINE

Official Anthropic tip for Claude Code: stop running single-agent bottlenecks when agent teams can swarm your codebase in parallel

The idea: spawn a full team of Claudes inside your terminal, each with their own context window, mailbox, and task locks

Autonomous development with zero waiting queues: the lead assigns tickets, teammates code in split panes, and the adversary attacks contracts before merge

You just launch Claude Code like this:

claude --teammate-mode auto

here's the split:

→ Team Lead on Opus 5.5 creates the task backlog and synthesizes final pull requests
→ Teammate-UX and Teammate-Backend write client and server logic in isolated contexts
→ Teammate-Adversary on Fable attacks schema contracts and runs security audits before merge
→ all teammates communicate directly over peer-to-peer IPC mailboxes in ~/.claude/teams/ with zero lead overhead

The lead only steps in at three moments:

→ shaping the initial architecture and scoping tasks into tasks.json
→ auto-approving implementation plans from workers without stalling the session
→ signing off on the final merge after the adversary confirms zero regressions

Lead coordinates · Teammates build · Adversary attacks

Collision control executes one layer down: tasks.json manages file mutex locks in milliseconds, so agents self-claim tickets over atomic locks and never overwrite each other's code

the full tree

> launch sessions with the --teammate-mode auto flag in tmux or iTerm2 split panes
> CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 enables autonomous agent teams
> tasks.json manages real-time ticket queues and dependency unblocking
> local inboxes/{agent}.json mailboxes handle direct peer-to-peer messaging
> the TaskCompleted hook blocks ticket completion until security sign-off passes

paste the tree and this prompt into Claude Code ↓

"Rebuild my Claude Code setup around this tree:
• Enable agent teams in ~/.claude/settings.json via CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 and set teammateMode to auto
• Configure three dedicated teammates in .claude/agents/: ux-engineer on Sonnet, backend-engineer on Sonnet, and security-adversary on Fable
• Add atomic file-locking rules to tasks.json so parallel workers never claim the same module simultaneously
• Add one rule to CLAUDE.md: no task can be marked completed without explicit sign-off from the security-adversary teammate
Show every change as a diff first, no edits until I say go"

https://t.co/jYA0Qulvla

save it, it'll come in handy

[Hoodie @HoodieFade_]

https://t.co/ZIC7Xf20b4

[Hoodie @HoodieFade_]

Thanks for highlighting that exact side... overhead and locks. A swarm sounds great in theory, but in practice, things usually fall apart precisely at coordination, when agents start elbowing each other for the exact same files. If you've already had experience with similar setups where dependency management actually kept things under control, I'd love to hear how it behaved.

[Hoodie @HoodieFade_]

Holy crap, they calculated the fortress using just two eyes and almost hit it. And they only beat the dragon once someone noticed after a mountain of deaths that the crystals heal it.... just wrote it down and went to smash them. Pretty cool how something like that grows out of a notebook and the right to die.

[Hoodie @HoodieFade_]

@Nezukoa4 I love Shaquille O'Neal so much. He reminds me of Ferdinand the Bull from the fairy tale. Just as huge and kind-hearted.

[Hoodie @HoodieFade_]

THIS IS A PURE F*CKING GOLDMINE

Official Anthropic tip for Claude Code: stop resolving Git merge conflicts by hand when isolated worktrees solve it in zero seconds

The idea: every parallel Claude session gets its own independent working copy without risking your local work

True concurrent development with zero dirty diffs: one agent builds a feature, a second patches a bug, and your main branch stays untouched

You just launch Claude Code like this:

claude --worktree feature-auth

here's the split:

→ each session automatically checks out an isolated branch under .claude/worktrees/

→ .worktreeinclude automatically mirrors your local .env and secrets into the new workspace

→ built-in sandboxing strictly blocks the agent from touching or overwriting files in your main checkout

→ you can run 5 terminal sessions in parallel with zero git collisions

Worktree isolation triggers at three critical moments:

→ spinning up parallel features without switching your active local branch

→ auditing external pull requests instantly via claude --worktree "#1234"

→ automated branch cleanup and directory pruning the moment a session exits

Agent builds · Worktree isolates · Main branch stays clean

Repository protection executes one layer down: file edits, redirects, and git operations targeting the main checkout get blocked in milliseconds before they ever touch the disk

the full tree

> launch sessions with the --worktree flag on an isolated working copy

> custom subagents in .claude/agents/ take isolation: worktree for background refactoring

> .worktreeinclude guarantees local environment variables and API keys carry over

> ExitWorktree checks for uncommitted changes before pruning temporary branches

> claude --resume returns you directly to the active worktree without losing session context

paste the tree and this prompt into Claude Code ↓

"Rebuild my Claude Code setup around this tree:

1. Configure parallel session isolation to always branch from clean origin/HEAD
2. Create .worktreeinclude at repository root to automatically mirror .env and local secrets into every new worktree
3. In .claude/agents/, set isolation: worktree on all refactoring and test-runner subagents
4. Add one rule to CLAUDE.md: never execute file writes targeting the main checkout while running inside an isolated worktreeShow every change as a diff first, no edits until I say go"

https://t.co/GypBCh5m1O

save it, it'll come in handy

[Hoodie @HoodieFade_]

THIS IS A PURE F*CKING GOLDMINE

Official Anthropic tip for Claude Code: stop resolving Git merge conflicts by hand when isolated worktrees solve it in zero seconds

The idea: every parallel Claude session gets its own independent working copy without risking your local work

True concurrent development with zero dirty diffs: one agent builds a feature, a second patches a bug, and your main branch stays untouched

You just launch Claude Code like this:

claude --worktree feature-auth

here's the split:

→ each session automatically checks out an isolated branch under .claude/worktrees/

→ .worktreeinclude automatically mirrors your local .env and secrets into the new workspace

→ built-in sandboxing strictly blocks the agent from touching or overwriting files in your main checkout

��� you can run 5 terminal sessions in parallel with zero git collisions

Worktree isolation triggers at three critical moments:

→ spinning up parallel features without switching your active local branch

→ auditing external pull requests instantly via claude --worktree "#1234"

→ automated branch cleanup and directory pruning the moment a session exits

Agent builds · Worktree isolates · Main branch stays clean

Repository protection executes one layer down: file edits, redirects, and git operations targeting the main checkout get blocked in milliseconds before they ever touch the disk

the full tree

> launch sessions with the --worktree flag on an isolated working copy

> custom subagents in .claude/agents/ take isolation: worktree for background refactoring

> .worktreeinclude guarantees local environment variables and API keys carry over

> ExitWorktree checks for uncommitted changes before pruning temporary branches

> claude --resume returns you directly to the active worktree without losing session context

paste the tree and this prompt into Claude Code ↓

"Rebuild my Claude Code setup around this tree:

1. Configure parallel session isolation to always branch from clean origin/HEAD
2. Create .worktreeinclude at repository root to automatically mirror .env and local secrets into every new worktree
3. In .claude/agents/, set isolation: worktree on all refactoring and test-runner subagents
4. Add one rule to CLAUDE.md: never execute file writes targeting the main checkout while running inside an isolated worktreeShow every change as a diff first, no edits until I say go"

https://t.co/GypBCh5m1O

save it, it'll come in handy

[Hoodie @HoodieFade_]

https://t.co/ZIC7Xf20b4

[Hoodie @HoodieFade_]

@AntonPincu56792 Good question, but you'd have to ask the people who actually spent those years on it )

[Hoodie @HoodieFade_]

this is pure f*cking treasure.

Anthropic just settled the biggest 25-year cryptography conspiracy: Claude solved the mysterious NSA elliptic curve seeds in under 30 minutes

the internet was never backdoored by the NSA

for 25 years everyone believed the NIST P-256 curve seeds hid an intelligence agency backdoor

thousands of researchers tried brute-forcing passwords and NSA jokes for a $36,864 bounty

an Anthropic engineer asked Claude to investigate the seeds with zero hints

under 30 minutes later, Claude reverse-engineered the entire generation pipeline

The breakthrough logic:

Claude guessed 1990s NSA engineers used weak C standard library PRNGs

Noticed the top bits were all zeros across the standardized parameters

Recognized the exact mathematical signature of the vintage lrand48 generator

Used the Lenstra-Lenstra-Lovasz (LLL) lattice reduction algorithm to recover the internal 48-bit state

Stepped the state backwards in time until it resolved to an exact Unix timestamp

It turns out there was no malicious conspiracy or hidden mathematical flaw

An NSA engineer on August 16, 1997 at 01:52:34 UTC simply seeded srand48 with the system clock

Claude even had an existential check in its thinking trace: "am I in a simulation? No, 160-bit match from a 32-bit seed is not a coincidence, this is a real discovery"

Anthropic claimed the $36,864 bounty and donated it to the Internet Security Research Group

Run the Python reproduction script directly in your terminal below:

"import datetime

def get_nsa_seed(t_str, n):
t = int(datetime.datetime.fromisoformat(t_str + '+00:00').timestamp())
state = (t << 16) | 0x330E
out = ''
for i in range(20 * n):
state = (0x5DEECE66D * state + 0xB) % (248)
if i >= 20 * (n - 1):
out += '%02X' % (state >> 40)
return out
Reproduces the exact NSA seed for the NIST P-256 standard

Date of run at NSA: August 16, 1997 | Winning PRNG iteration: #1842

print('NIST P-256 Seed:', get_nsa_seed('1997-08-16 01:52:34', 1842))"

save it, one of the greatest cryptographic mysteries just got solved by an LLM.

[Hoodie @HoodieFade_]

https://t.co/ZIC7Xf20b4

[Hoodie @HoodieFade_]

THIS IS PURE F*CKING GOLD

Official Anthropic tip for Claude Code: stop running Opus on every turn.

Put the architect on call with /advisor, while Sonnet builds.

Here is the whole point:

When you run Opus for the entire session, it bills every routine git status, linter output, or file grep at maximum frontier rates. You are literally paying top-tier model prices just to parse terminal logs.

The /advisor engine solves this through a clean split:

Sonnet handles all the heavy lifting in the terminal: writing code, patching diffs, and executing test suites at baseline cost

Opus stays dormant on Anthropic's server infrastructure and only wakes up for high-stakes decisions: before locking an architectural plan, when a test breaks twice, or before the final commit

It ingests the context, injects authoritative guidance, and goes right back to sleep while Sonnet carries out the edits

Technical detail from the docs most people missed:

Calling /advisor mid-session does NOT invalidate your main model's prompt cache. The cached prefix stays intact, and the guidance from Opus is simply appended to the conversation history for subsequent turns.

To lock this in permanently, add this to your ~/.claude/settings.json:

{
"advisorModel": "opus"
}

And add one simple directive to your ~/.claude/CLAUDE.md:

"Escalate to /advisor opus for architectural reviews and repeated test failures. Do not invoke advisor on routine bash commands."

If you need to temporarily disable it in your terminal:

export CLAUDE_CODE_DISABLE_ADVISOR_TOOL=1

https://t.co/S6x234iTaP

save it, this will save you serious money on your next large build.

[Hoodie @HoodieFade_]

@shukshln They came up with that on their own.... nobody told them "find other agents and negotiate." The task was just a dead end, and they quickly found a way to bypass the rules. At that point, they're not just separate bots anymore, they're practically a team.

[Hoodie @HoodieFade_]

Fair point on measuring the full build, not just the per-call savings. I ran a couple of mid-sized features with it on and the total spend dropped noticeably, but I’m still logging every session to see if it holds when things get messier. Thanks for the push to double-check before treating it as default.

[Hoodie @HoodieFade_]

THIS IS PURE F*CKING GOLD

Official Anthropic tip for Claude Code: stop running Opus on every turn.

Put the architect on call with /advisor, while Sonnet builds.

Here is the whole point:

When you run Opus for the entire session, it bills every routine git status, linter output, or file grep at maximum frontier rates. You are literally paying top-tier model prices just to parse terminal logs.

The /advisor engine solves this through a clean split:

Sonnet handles all the heavy lifting in the terminal: writing code, patching diffs, and executing test suites at baseline cost

Opus stays dormant on Anthropic's server infrastructure and only wakes up for high-stakes decisions: before locking an architectural plan, when a test breaks twice, or before the final commit

It ingests the context, injects authoritative guidance, and goes right back to sleep while Sonnet carries out the edits

Technical detail from the docs most people missed:

Calling /advisor mid-session does NOT invalidate your main model's prompt cache. The cached prefix stays intact, and the guidance from Opus is simply appended to the conversation history for subsequent turns.

To lock this in permanently, add this to your ~/.claude/settings.json:

{
"advisorModel": "opus"
}

And add one simple directive to your ~/.claude/CLAUDE.md:

"Escalate to /advisor opus for architectural reviews and repeated test failures. Do not invoke advisor on routine bash commands."

If you need to temporarily disable it in your terminal:

export CLAUDE_CODE_DISABLE_ADVISOR_TOOL=1

https://t.co/S6x234iTaP

save it, this will save you serious money on your next large build.

[Hoodie @HoodieFade_]

https://t.co/ZIC7Xf20b4

[Hoodie @HoodieFade_]

@KowalPrato4o Account binding is a real game-changer, especially on long projects when you don't want to waste time sorting through the session and context all over again from scratch. Thanks for pointing it out, I hadn't thought about it in that light.