Andrej Karpathy, who helped start OpenAI and ran AI at Tesla, open-sourced a script that lets one GPU do a night of research on its own, roughly 100 experiments while you sleep
a builder took the logic behind it and rewrote it as a single Claude prompt: your task gets broken into small checked pieces, Fable 5.2 runs the plan, and cheaper models do the grinding
i didn't expect this to work this f*cking well...
drop it into Claude Code tonight. on a 22 million token bug hunt, that same brain-and-hands split cut the bill from 563 dollars to 165
Claude Fable 5.2 is the most insane AI model in history...
99% of people will never touch it or burn money on it: "Too expensive", "Not for me"
Use it right, and it becomes your second BRAIN, for a fraction of the price
In this article, I show you how:
12
364
Lauren Tan’s router tree is basically a filter for deciding how your AI should split the work before it touches any of it
every incoming request goes through 4 questions:
→ many items, same job on each?
→ does each step need the last one?
→ is it a judgment call with no single right answer?
→ is it long, messy and likely to break?
then it gets one of 5 outcomes:
fan-out / chain / debate / supervisor / simpler
the useful part is that the router never does the work itself. it only decides the shape
and that's exactly the job Anthropic gave Fable 5.2. on its launch page it's an orchestrator: it plans, splits the work and judges the result, while Opus builds, Sonnet checks and Haiku does the volume
sometimes the job needs the brain, a plan or a root cause.
sometimes it needs cheap hands, 800 tickets to tag.
sometimes it's one chain of steps, and one model at lower effort is cheaper than any team.
shape + model + effort → the bill
on a 22 million token bug hunt, Fable doing everything cost 563 dollars. Fable as the router with Sonnet as the hands cost 165
Lauren's full router tree below ↓
this one page explains Fable 5.2 better than most hour-long videos
someone turned the whole Fable 5.2 masterclass into a single page with a line that should make every Claude Code user stop:
let Haiku do the volume, let Sonnet check, let Opus build, let Fable think
the main point comes down to one sentence:
the most expensive model shouldn't be doing most of the work
in plain words:
49% of people never touch Fable because it looks too expensive. the other 49% run it on everything and burn their limits on renames and tagging. per token it costs 80x what Haiku does
the page asks a simple question:
what if Fable only did the thinking?
here's the setup:
1. Fable on /brain plans the job, briefs the team and judges the result
2. Opus builds from a clear brief
3. Sonnet checks the finished work and changes nothing
4. Haiku does the volume and never writes code
the key detail: same job, same 22 million token bug hunt. Fable alone ends at 563 dollars. Fable as the brain with Sonnet as the hands ends at 165, 71% cheaper, for a somewhat lower score
and the rest fits in one evening: /effort high, one CLAUDE block that makes it finish what it starts, and deleting old lines like "double-check your work" that it no longer needs
so the skill stops being which model you pick, and starts being which job you hand to which model
the page in one line:
let Haiku type, let Fable think
Claude Fable 5.2 is the most insane AI model in history...
99% of people will never touch it or burn money on it: "Too expensive", "Not for me"
Use it right, and it becomes your second BRAIN, for a fraction of the price
In this article, I show you how:
1
13
607
stop wasting hours trying to learn REA
it hit number one on GitHub trending, and here is one practical roadmap: the install, the 4 agents, the wall, real runs and the exact order to learn it
START HERE
1. check Node: 22.19+, 24.11+ or 26+
2. npx rea-agents setup, pick Claude Code, approve the plan
3. rea doctor to see what works on your machine
4. rea update, v6.7 shipped with 236 merged PRs
5. add an engine only if you need it: Ghidra, Hopper or IDA for native apps
6. Electron and .NET need nothing extra
then ask Claude Code: what REA tools do you have?
BUILD THE TEAM
1. analyst: the only agent that touches the target, tags every claim as observation, inference or unknown
2. spec writer: behavior only, no addresses, no decompiled names
3. rebuilder: its own container, no REA in its tools at all
4. verifier: runs both builds on the same inputs, never edits anything
5. one script that drives both rooms for up to 3 rounds
6. wall check: which rea, npx rea-agents and ls the lab must all fail inside the container
ACTUAL REA RUNS
1. a DX-Ball sound function rebuilt, 3,205 original x86 test cases passed, all 63 compiled bytes reproduced
2. a public count of agents taking apart software and hardware hit 286 cases, 119 of them with REA
3. Perplexity turned REA into a built-in skill for its Computer agent
THE NUMBERS
v6.7: 236 merged PRs from 120+ contributors
"software is done": 3.8 million views
a single chat starts drifting around function 40
max 3 rounds, because a rebuild still wrong after 3 usually has a gap in the evidence
OPTIMAL ORDER TO LEARN
install → doctor → one Electron or .NET app you own → analyst on one feature → spec + leak grep → rebuilder in a container → verifier → then Ghidra and native binaries
REA hit #1 on GitHub trending, and most people still run it inside a single chat
Split it into 4 subagents and one command takes a program you own from sealed binary to a tested rebuild with a match rate
Set it up once, aim it at the next one:
1
4
357
this is getting f*cking scary...
someone just dropped a setup that turns Claude Code into a full reverse engineering team built on REA
one run and your agents will:
- open an app you own and tag every finding as observation, inference or unknown
- turn it into a spec with zero addresses and zero decompiled names
- rebuild the feature in a sealed container that has no REA at all
- run the original and the rebuild side by side and give you a match rate
and that's only the beginning...
4 agent files, 2 rooms, 1 script that loops up to 3 rounds until nothing's wrong. send it to Claude Code and thank me later
only on software you own or are allowed to examine. one feature at a time
REA hit #1 on GitHub trending, and most people still run it inside a single chat
Split it into 4 subagents and one command takes a program you own from sealed binary to a tested rebuild with a match rate
Set it up once, aim it at the next one:
2
12
452
holy sh*t, someone just dropped a full Fable 5.2 masterclass for Claude Code, 10 prompts in one evening
Fable more than doubled Opus on real paid remote work, 41.3% vs 21.3%, and this setup turns "why is my bill so high" into a 4-model team that costs 71% less
the team:
→ /brain on Fable for the plan and the final call
→ opus-builder for the build
→ sonnet-checker for the review, changes nothing
→ haiku-worker for the volume, never code
→ an advisor line for the 3 moments that matter
→ a CLAUDE block for finishing what it starts
10 prompts, 4 files, paste the start here prompt and answer 3 questions
every model follows the same rule: the cheapest one that can do the job does the job
hand it one big job first, the bigger the job, the more the team pays off
Claude Fable 5.2 is the most insane AI model in history...
99% of people will never touch it or burn money on it: "Too expensive", "Not for me"
Use it right, and it becomes your second BRAIN, for a fraction of the price
In this article, I show you how:
3
8
321
Fable 5.2 just got f*cked by its own cheaper siblings...
one setup turns the most expensive model in Claude Code into the brain of a 4-model team, and the same job costs 71% less
Fable isn't too expensive anymore.
here's how to set up brain mode:
first understand how it works:
• Fable plans, splits the job, briefs the team and judges the result
• Opus builds, Sonnet checks and changes nothing, Haiku does the repetitive work and never writes code
• Anthropic's 22 million token bug hunt went from 563 dollars with Fable alone to 165 with Fable as the brain
here's how to set it up in one evening:
1 → update Claude Code to v2.1.321 or later, then /model fable and /effort high
2 → say: "set up my Fable 5.2 team at user level: an opus-builder, a sonnet-checker, a haiku-worker and a /brain skill on Fable. show me every file before you create it"
3 → it writes the 3 agent files and the brain skill, each with its model inside, and adds an advisor block to your CLAUDE file
4 → restart Claude Code once if the agents or skills folder didn't exist before
5 → the step everyone skips: hand it a whole job, not a question. /brain move the API from Python to Rust, done means every test passes and the service starts
6 → type /tasks to see which model each helper runs on
7 → want it even cheaper? swap fable for opus in the brain skill. in Anthropic's test, about the same score and 19% cheaper
a team only pays off when the job is bigger than one session or splits into parts that don't depend on each other. for one chain of steps, a single model at lower effort is cheaper
holy sh*t, someone just dropped a full reverse engineering team for Claude Code, built on REA
REA hit number one on GitHub trending, and this setup turns "why does my rebuild keep drifting" into 4 agents that check each other
the team:
→ analyst for the target and the evidence
→ spec writer for behavior only
→ rebuilder in its own container, no REA
→ verifier for the match rate
→ a leak check for addresses and decompiled names
→ one script that runs both rooms
7 steps, 4 agent files, give the script a target and one feature and run
every agent follows the same rule: one job, its own context, and only the tools that job needs
point it at one feature you own, the smaller the feature, the more the match rate means
REA hit #1 on GitHub trending, and most people still run it inside a single chat
Split it into 4 subagents and one command takes a program you own from sealed binary to a tested rebuild with a match rate
Set it up once, aim it at the next one:
4
23
1,083
this is f*cking insane, "subscribe to unlock" just got its gravestone, 2014 to 2026, and the cause of death is one model, a few open-source repos and a 9 step pipeline
the timeline moved fast:
→ Cloudflare rebuilt Next.js with AI in a week for about 1,100 dollars in tokens, builds up to 4x faster, bundles 57% smaller
→ then came an open Cursor, an AirDrop for Windows, an open Claude Design with 5,500 stars
→ one dev shipped 10 of his own versions of paid-style apps in 18 days, 13,000+ downloads, 0 lines typed by hand
→ one of them sat at 5 stars for a day, then hit 210 in 48 hours after the launch post
what made it work is less magic and more process
the code turned into the easy part. the hard part is the pipeline: map the original read-only with REA, design 9 live concepts before any app code, write one contract so 27 agents never touch the same file, and let a safety agent attack every delete. that agent found 11 real bugs before launch
so the line looks like this:
• studying how a product behaves and writing a spec, that's research
• building your own version from that spec with your own code, names and icons, that's a product
• copying their code, strings or brand, that's what a no-copy check is there to fail
tell Claude Code to map one app you pay for, list the 20% of features that give 80% of the value, and flag anything that needs their servers or assets so you skip it
the feature you pay for every month might be one weekend of agents away from being yours
REA is the most powerful thing on the internet right now
it lets your AI agent reverse-engineer any app from scratch
i connected REA to Opus 5.5 and reverse-engineered paid 10 apps that gained 13K+ installs
in this article, I reveal the full workflow:
3
8
351
closed source just lost its last f*cking secret...
one open-source repo now lets Claude Code read the apps on your computer down to the function, the file and the line, and it costs nothing
"nobody can see how it works" stopped being true.
this is REA, reverse engineer anything, and here's the whole thing in plain words:
what it actually does:
• it connects to Claude Code through MCP and adds a skill for investigating features
• you ask a normal question, it looks inside the program, and every answer shows its proof
• everything stays on your machine, nothing gets uploaded
getting it running:
1 → check your Node version first: 22.19+, 24.11+ or 26+ work, 23 and 25 don't
2 → tell Claude Code: "install REA and connect it to this coding agent using npx rea-agents setup. show me the setup plan for approval, then verify the installation"
3 → choose Claude Code when it asks. it shows every change before touching anything and saves a backup of your config
4 → restart the session and ask which REA tools it has now
5 → don't jump to big apps. start with the official notes demo, press export, and watch it trace that one click through 4 files
6 → for games and programs plug in Ghidra or Hopper, for Android apps add JADX
7 → once it clicks: investigate the feature, write a spec with zero copied code, build your own version, test it until it matches
use it on software you own or are allowed to look into, and build your own from what you learn
save this for the next time a paid app does something clever and you wonder how
REA is most dangerous thing on the internet right now...
It lets your AI agent reverse engineer any app, down to the binary
If you use it correctly, you can rebuild any feature you pay for, for FREE
In this article, I show you how:
10
700
listen. Claude Code is a free degree and almost nobody finishes it. this is f*cking wild
7 steps take you from one prompt to a team of agents. no course, no bootcamp, about one weekend if you go in order
the 7 steps:
1. memory file: /init writes the rules Claude reads on every start
2. skills: teach a how-to once, every session reuses it
3. MCP: plug in GitHub, Slack and your docs
4. hooks: checks that run before and after every action
5. subagents: one job per agent, each with its own context
6. routines: claude -p plus cron, so work moves while you sleep
7. team: git worktree, you write the job and the check
the final exam is reverse engineering:
1. REA installs as an MCP connection plus a skill in one command
2. it shows you the plan before it changes anything
3. you ask how a feature works and get the function, file and line
4. Claude writes a spec with no copied code
5. you build your own version and test it against the original
5 mistakes that keep people stuck on step 1:
1. treating Claude Code like a chatbot with a terminal
2. writing the same instructions every session instead of a skill
3. no hooks, so nothing checks what the agent just did
4. one giant session doing five jobs
5. jumping to agent teams before routines work
best order:
memory → skills → MCP → hooks → subagents → routines → team
save this and do one step a day. by the end of the week you're running agents instead of prompting one
this is the most f*cking useful 5 minutes you'll ever spend on Claude Code
your notes are the reason your AI guesses. untitled 7, important!!, tax stuff, and one misc file holding 8 different topics. it has no idea where anything is, so it fills the gaps with whatever sounds right
the fix needs no app. 3 folders of plain text, notes, people and projects, plus 1 map file that loads before your first question and points every topic to its file
rename once and it stops guessing:
untitled 7 → maria-lopez
important!! → decisions
misc → 8 files, one topic each
tax stuff → tax-policy
now ask what ivan said about pricing and it opens his card and quotes it. ask for maria's phone and it tells you her file has no number and it won't invent one
paste this into Claude Code:
"Turn this folder into a second brain. Sort my notes into notes, people and projects, one topic per file, lowercase with hyphens. Write a map file that says what lives where. Always answer from one file and name it. If it's not written down, say so. Show me the renames before touching anything"
your AI is only as good as the map you give it
4
16
592
holy f*ck... ur AI can now remember everything u tell it. no Obsidian, no Notion, no database
the whole setup is 3 folders of plain text files and 1 map file that Claude Code loads before ur first question. the map says where each topic lives, so the agent opens one file instead of digging through all of them
on a folder of 14 files, it reads exactly 1 per question and names it. ask about something that isn't written down and it says no file covers it, won't guess, and offers to create one
it comes down to 4 steps:
step 1 → make 3 folders: notes for facts, people for contacts, projects for status
step 2 → one topic per file, named after what's inside, lowercase with hyphens
step 3 → write the map: where things live, what stays in focus, cite every answer
step 4 → one rule on top: not in the files means say so
that's why a messy notes app never works with AI. note-12 and stuff final (2) tell the agent nothing
paste this into Claude Code in an empty folder:
"Build me a second brain here. Create notes, people and projects folders, plus root files for memory, lessons and decisions. Write one map file that says where each kind of info lives. One topic per file, lowercase with hyphens. Answer only from the file the map points to and name it. If nothing covers it, say not found. Show me the plan first"
try it tonight, it takes 5 minutes
3
21
783
this is free f*cking gold
for anyone who thinks Grok Bot routines are just cron jobs. with the right setup, one office runs 14 of them on 5 floors and barely touches ur usage
the trap is one 5 min check that reads the full page every time. 8,640 wake-ups a month, almost all saying no_change
the moves almost nobody uses:
→ read the hash first and stop if nothing moved
→ webhooks instead of polling where u can
→ a default answer for night approvals
→ a monday audit that tells u what to slow down
send this to Grok Bot:
audit my routines. for each one show how often it runs, how often it finds a change, and what it costs. move anything under 5% changes to a slower floor, add a hash check before every full run, and give every night approval a default
check the cadence before u check the prompt
this is f*cking wild. one Python file now decides what every worker in ur AI agent does next, and each decision costs about four thousandths of a cent
it runs on Jev, a model that never writes a single word. it reads the state of a task and picks the next move, with a confidence attached
three runs of the same file:
→ "compare three AI agent tools, no sources yet" → research, 0.97 confidence, 214 ms
→ same task after notes were added → write, 0.91
→ "publish it tonight" → stopped at review, because anything public always needs a human yes
and everything around the decision is plain code:
- under 0.85 confidence, a human looks first
- 10 actions max and a hard spending cap for one overnight run
- progress saved after every step, so an interruption resumes instead of starting over
- the menu of workers gets rebuilt every step, so it never picks from yesterday's options
- a confident "done" means nothing until the code checks the file actually exists on disk
the LLM writes. Jev decides. code executes
10,000 decisions at this size cost about 42 cents
the full 10-step setup, with the whole file, is in the article below ↓
this is f*cking insane. Matthew Berman, after testing one open-source repo:
"Reverse Engineer Anything. Software is done."
two days later he posted the demo: Claude reading software it had never seen, down to the binary, and explaining exactly how it works
here's the system behind it:
step 1 → give Claude a workspace where the target is read-only and it can't call the internet. it only writes to its own notes
step 2 → one rule in the project file: tag every finding confirmed or guess, with the file and line it came from
step 3 → let free tools do the mechanical part first, an unbundler for minified code, a disassembler through MCP for binaries
step 4 → then Opus 5.5 does the reading: renames every meaningless function by what it does, maps the data flows, writes the spec
a 120K line repo that takes 3 to 4 days by hand gets a usable map in about 20 minutes
target → read-only workspace → mechanical pass → Opus reads → confirmed or guess → spec
the whole guide boils it down to one line: reverse engineering is 90% reading and 10% writing
anyone can ask Claude to write code. the real unlock is letting it read the code nobody documented
this one setup is worth more than most paid reverse engineering courses, and one target costs under 6 dollars
bookmark it and set it up today
then read the full guide below ↓
2
3
438
listen. i still don't get why nobody is talking about this. it's a f*cking goldmine
one Claude Code setup on Opus 5.5 reads code nobody documented, apps with no public API, minified bundles, old binaries and weird file formats. a week of digging fits into one afternoon for under 6 dollars
start here:
1. one folder per target: the code goes in target, Claude writes findings to notes
2. lock the target read-only and block network calls in the project settings
3. one rule in the project file: tag every finding confirmed or guess, with file and line
4. one long session per target, so every follow-up hits the cache for about 8 cents
the 6 workflows:
1. map an unknown repo: entry points, 5 data flows, a module diagram, anything weird
2. rebuild an API from traffic: browser capture, redact tokens, get a spec and a typed client
3. deobfuscate minified JS: a free unbundler first, then Opus renames every a, b and t
4. decompile binaries: a disassembler connected through MCP, 30 functions at a time
5. crack unknown file formats: 3 to 5 samples, a spec and a parser
6. audit what u shipped years ago and lost the source for
tools that do the mechanical part:
1. REA, one setup for Ghidra, Hopper, IDA, JADX, WASM and firmware github.com/morluto/rea
2. GhidraMCP, the original free one github.com/LaurieWired/Ghidr…
3. ghidra-mcp fork with 209 tools github.com/bethington/ghidra…
4. cerberus-re for ur own Apple apps github.com/OwenPawl/cerberus…
5. webcrack for webpack bundles, mitmproxy for mobile traffic, Kaitai Struct for file formats
5 mistakes that cost u days:
1. skipping confirmed vs guess
2. feeding raw traffic with cookies still inside
3. letting Claude write to the target
4. a fresh session for every question
5. trusting renames without spot-checking 10%
best order to learn:
lock the workspace → map one repo → rebuild one API → deobfuscate one bundle → then binaries and file formats
only on code u own or are allowed to study. the full setup with every config and prompt is in the article below ↓
the 15-minute routine is f*cked
i'm not exaggerating. the people who build Grok Bot run a whole city of bots overnight, and most of the night they just stay quiet.
one written job per bot. proof before "done". runs only when something changed.
from evening to dawn: 54 runs found nothing new and stopped, 25 jobs got delivered, and 0 needed a human.
look at what's running in that city on the same plan:
→ a Chief that turns a voice memo into its job and drafts a plan before touching anything
→ a Gate that asks first before anything leaves the building
→ a Desk that watches markets and logs alerts, and never places a bet
→ a Builder that never writes code, it hands a cloud agent one prompt and closes only with before and after screenshots
no new model. no bigger plan. no extra tools. no babysitting.
u are paying for runs that wake up every 15 minutes to find nothing.
read that again.
every Grok Bot user still running timers in 2026 is burning their week by Wednesday.
bookmark this now. send it to the one friend whose bot is "still thinking"
f*cking unreal... Claude Opus 5.5 just turned 15 seconds of code into a paid motion design gig
one afternoon builds the sample, one more prompt finds the client who already posted the job
here's how to land ur first order, step by step:
step 1 → open Claude Code on Opus 5.5 and start a blank Remotion project with its skills installed
step 2 → write four beats for a 15-second product demo, scattered cards pulling into one clear view, and label it as a concept
step 3 → let Opus build it frame by frame, rough preview first, polish only after the story reads
step 4 → have it grab a contact sheet every second, fix the 3 worst problems and stop after three passes
step 5 → export a widescreen and a vertical version from the same film, then post it as self-initiated work
step 6 + the payoff → an agent searches public requests, scores them against ur sample and drafts one proposal you send yourself. buyers were paying $300 for a 15-second product video, $500 for a SaaS promo and ~$2,000 for a B2B demo
price it from ur own hours, not from hype. 5 hours at $40 plus costs and a 10% fee is a $244 quote u can defend
stop scrolling motion reels and start invoicing them. the full zero-to-first-order guide is in the article below ↓
It's probably the easiest way to make money with ONLY AI in 2026...
Companies are already offering ~$500 for 15-sec videos made with Opus 5.5 & Fable 5.5
In this article, I'll walk you through building a motion studio and share offers from scratch:
1
16
625
this is f*cking insane
whoever dumps trash in the street at night has no idea a drone can now find every pile, pin it on a map and keep the video
all it takes is a spare phone and one Claude Code session on Opus 5.5, and nothing gets uploaded. the whole thing runs on the phone clipped to the remote
how the flight works, from takeoff to the report:
- Opus 5.5 first checks whether the drone is supported by the official DJI SDK. if it isn't, the build ends there, nobody touches the firmware
- it writes a small app on that SDK, Swift if the phone is an iPhone, Kotlin if it's Android
- a compact detection model runs on the phone's own chip and boxes every pile the camera passes
- each pile gets a single ID the moment it's seen, so crossing the same block twice never doubles the count
- what the camera sees gets projected onto the ground, and every pile lands as a pin next to the flight path
- optical flow reads the ground speed live, so distance and timing stay honest without trusting GPS alone
when it lands, the phone already holds three things: a map of the route with every pile on it, a timeline showing when each one came into view, and a short clip for every find
that's not a complaint anymore, that's evidence a cleanup crew can follow pile by pile
the prompt is in the comments, and the article below shows how Opus 5.5 takes software apart in the first place
REA is most dangerous thing on the internet right now...
It lets your AI agent reverse engineer any app, down to the binary
If you use it correctly, you can rebuild any feature you pay for, for FREE
In this article, I show you how:
11
21
507




















