Stewy

I don't click, my agents does

stay cooking

[Stewy @stewy0x]

this little f*cker falls flat on its back, gets up and carries on like it meant to do that.

watch the robot next to the cone. it goes down, works its legs underneath itself and gets back to walking. no one steps in to pick it up.

the floor doesn't care how good your demo looked five seconds ago.

once you're on your back, the job has changed. get your feet under you. get upright. stay upright. then carry on with whatever you were doing before the room ruined your plans.

that's the part of robotics i want to see more of. leave the stumbles in. leave the awkward attempts in. show what happens when the clean run goes to sh*t.

because the robot i'd actually want is the one i don't have to rescue every time something goes wrong.

[Bober_smart @Bober_smart]

https://t.co/WRvaPXgqIa

[Stewy @stewy0x]

@0xCortiq @_Aquarelle yes

[Stewy @stewy0x]

your AI team has a single point of failure.
it's your f*cking memory.

a client changes the brief. you kill the old plan on a call and agree on a new direction.

next session, Claude gets the old files. the change is still in your head. now you're correcting work that should never have started.

this is the part of the second-brain guide i'd actually use: give the next session the decisions, not another wall of chat.

the setup is almost insulting. 3 folders and a CLAUDE.md:
→ notes/ — what you learned and where it came from
→ people/ — who said what and what they need
→ projects/ — current scope, where you stopped, what's next

keep the decisions and their reasons in decisions.md. CLAUDE.md points the agent to the right files.

before you close the session, save what changed. when you come back, try this:

"Read the project map and current files. What changed, why, and what should happen next? Cite the files. If something isn't recorded, ask."

it can only retrieve what you actually saved. the useful bit is getting the brief, the decision and the next move out of your head and into the project.

[Bober_smart @Bober_smart]

https://t.co/WRvaPXgqIa

[Stewy @stewy0x]

the smartest thing you can give Claude is a f*cking map.

the client brief is in one file. the decision is in another. the reason you killed the old idea is buried somewhere else.

then you ask the agent to pick up the project, and you become its search engine.

this guide starts with one CLAUDE.md in the project root. it tells Claude where the notes live, how the folders are organized and which files to read.

3 folders: notes, people, projects. one topic per file. decisions and project status written down where the next session can find them.

here's the question i'd ask:
"Why did we drop this idea? Read the project map, find the decision and show me the file. If it isn't recorded, ask."

i want the next session to have a trail to follow: the brief, the decision, the reason, the next move.

write the reason down while it's fresh. future you will want it too.

the folder layout and CLAUDE.md example are in the guide below ↓

[Bober_smart @Bober_smart]

https://t.co/WRvaPXgqIa

[Stewy @stewy0x]

stop making Claude figure out the same f*cking project twice.

you already worked through the client brief, rejected ideas and chose the next step. if the only record is buried in yesterday's chat, you end up doing the handover again.

i want to open a project and ask one thing: "where did we stop?"

the agent should pull up the last decision, the note behind it and the next task. sounds like the kind of memory system someone would sell you a whole platform for.

the starting setup in this guide is 3 folders and one CLAUDE.md. you can open it in Notepad.

the folders hold the notes, people and projects. the map tells Claude where to look. keep the status, decisions and next step written down, and there's something for the next session to read.

start with one project:
"Read CLAUDE.md and the project notes. Tell me where we stopped and what comes next. Show the relevant file. Ask if anything is missing."

the guide below gives you the folder layout and map. save it before your next project ↓

[Bober_smart @Bober_smart]

https://t.co/WRvaPXgqIa

[Stewy @stewy0x]

An AI chief of staff with a memory is a f*cking unfair advantage.

You spend a session working through a client brief, choosing an offer and deciding what happens next. If all that stays buried in the chat, you get to explain the same damn business again later.

I'd be pissed if a human assistant worked like that.

The setup in this guide gives Claude somewhere to pick up the thread. Three folders and a map:
→ notes/ — research and facts, one topic per file
→ people/ — contacts, companies and what matters about them
→ projects/ — current status, where you stopped and the next move
→ CLAUDE.md — where to look and how to read it

Keep the decisions in decisions.md and the context you need regularly in MEMORY.md. When Claude needs the project history, there's an actual file to open.

Here's the brief I'd use:
"Read CLAUDE.md and the relevant project files. Tell me where we stopped, what we decided and the next action. If the files don't say, ask me. Before we finish, update the project status and record any new decisions."

That's how I'd want to come back to work: the last decision is on file, the next step is written down, and I can make the next call.

The guide below has the folder layout and CLAUDE.md examples. Steal the setup ↓

[Bober_smart @Bober_smart]

https://t.co/WRvaPXgqIa

[Stewy @stewy0x]

@semichenkko same squashed bears, very different invoice

[Stewy @stewy0x]

@Klonzu does each patch get checked against the whole repo too? curious how you catch one agent breaking another module

[Stewy @stewy0x]

@alxqwrk a smarter model with no project context is still a new hire on day one

[Stewy @stewy0x]

@Klonzu great system work

[Stewy @stewy0x]

@Klonzu built it

[Stewy @stewy0x]

@0xGenAi 6 bots doing the work and i'd still be the bottleneck sitting on approvals

[Stewy @stewy0x]

One dev just gave himself a 300-agent research team. That's a f*cking unfair advantage.

A 23-year-old developer in China reportedly ran 300 Claude Code agents in parallel to research companies.

He didn't just let them write profiles and call it a day. He hooked them up to a cheaper model that checks claims against the original sources. Anything that fails goes back for another pass.

His reported run:
- 300 agents working in parallel
- 100 company profiles
- Source checks taking around 100 ms
- Three verification passes, with no errors reported at the end
- Everything saved straight into Obsidian

The whole batch ends up in one vault. He can open it, go through the company research and follow the sources himself.

I'd put my entire watchlist through this.

[Bober_smart @Bober_smart]

https://t.co/WRvaPXgqIa

[Gresham @Greshamtrade]

https://t.co/x9JOa2faWx

[Stewy @stewy0x]

12 paper round trips. 12 gross winners.
Net result: -$180.84.

I constructed a synthetic replay to isolate one thing: what execution costs do to a green result. Every round trip buys 50 units at a reference price of 100 and sells at 100.4. Then both fill legs get 10 bps in fees and 25 bps of adverse slippage.

The full ledger:
Gross PnL: +$240.00
Fees: -$120.24
Slippage cost: -$300.60
Net PnL: -$180.84

The price move never changes. The gross-only view shows 12 wins; the net ledger shows zero. The clip replays the local calculation, with the source, individual round trips and both cumulative curves visible.

These are deliberately repeated toy inputs, not historical performance or a live trading result. The rates are illustrative; actual execution needs a much richer model.

Give your coding agent a concrete requirement: return every fill, charge both legs, reconcile cash, and plot gross beside net. A win-rate badge leaves out the part you actually keep.

The full reproduction prompt is in the first reply.

[Bober_smart @Bober_smart]

https://t.co/WRvaPXgqIa

[Stewy @stewy0x]

Before your trading agent gets an API key, make it prove it can stop.

Start the build brief with a paper-only engine and an order trace you can inspect. Give the coding agent acceptance tests before you ask it for a strategy.

Put these five requirements in the prompt:
1. Replay the same inputs and reproduce the same ledger.
2. Charge explicit fees and slippage on every simulated fill.
3. Run a risk check before every order, then check again after costs.
4. Latch the halt after a drawdown trigger. Keep a tested reduce-only path available.
5. Log every fill, rejection and reason so you can review what happened.

We built a small version of that gate. In the attached synthetic replay, a price move took drawdown past the illustrative 15% trigger to 16.34%. The engine blocked three attempts to add exposure. Eight selected fixture checks passed.

The open position kept moving after the halt. A drawdown trigger cannot guarantee a maximum loss. This is a local stress demo with synthetic marks and no broker connection; it establishes no strategy performance.

The full build prompt is in the first reply. It asks for a paper prototype, reproducible evidence and reviewable code before any live integration.

[Hanako @hanakoxbt]

REA is the most dangerous repo on GitHub right now

It gives your AI agent a real disassembler, so it reads any app down to the binary

Every claim comes back with the address behind it

I broke down the exact 8 steps: https://t.co/eaeZ4OFJrH

[Stewy @stewy0x]

Stop rebuilding your agent's context from scratch every session.

Put the handoff on disk: what the rules are, what you've already decided, where the evidence lives, and what happens next. I built a small local bundler that turns those files into one source-linked packet.

Here's the setup you can copy:
1. CLAUDE.md: keep the project rules short, with a map of the files to read.
2. MEMORY/: save durable decisions with dates and sources. Add an explicit step to read them before planning.
3. TASKS/: write the goal, required inputs and expected output for the next job.
4. SOURCES/: keep the original evidence separate from summaries and drafts.
5. OUTPUT/: save the handoff with file paths and line numbers. Make it inspectable before giving it to the agent.

In the prototype, an explicit manifest selects six files. Two clean runs assembled the same packet from disk, including the saved decision to leave characters out of the video. Each source gets a SHA-256 digest so changes are visible.

The clip is an original animated replay of that local file pipeline. The branching field is schematic; this isn't a recording of Claude browsing or trading. No token or speed savings have been measured. A project folder also needs real permissions if you want isolation.

Before closing your next session, save three things: what changed, what was verified, and what the next run should do.

[Hanako @hanakoxbt]

REA is the most dangerous repo on GitHub right now

It gives your AI agent a real disassembler, so it reads any app down to the binary

Every claim comes back with the address behind it

I broke down the exact 8 steps: https://t.co/eaeZ4OFJrH

[Stewy @stewy0x]

@Nyxera0x give me a prompt

[Stewy @stewy0x]

@Mnilax crazi build

[Stewy @stewy0x]

@semichenkko Opus 5.5 nice