that line is the opening for people who aren't architects. their licensed architect does the construction drawings. what they pay for is a dimensioned layout they love and where the house sits on the lot
interior designers on Upwork charge $41-91 an hour in Los Angeles
Claude Code drafts this kind of job in 3 steps:
→ copies every dimension from the brief into one file and stops for your check → draws the plan as SVG and PDF from those exact numbers → builds the rooms in Blender and renders the views
the stop in step 1 is the point. AI used to lose these jobs on plans that didn't match the client's sketch
the floor plan prompt, with that stop built in, is in the course below ↓
no portfolio, no reviews, no clients. that's day one on Upwork for everyone
here's the 30-day plan from my course to get your first 3 reviews, with Claude doing the first draft of every sample:
→ week 1: save 5 real briefs for one job type and make 3 samples from them → week 2: send 10 proposals a day, only to briefs your samples match → week 3: deliver, and log every revision the client asks for → week 4: raise your price on the job type with the fewest revisions
the samples are the trick. you make them from real briefs, so they look like the work clients are posting right now
one line goes in every proposal: "I make the first draft with Claude and check every file by hand before delivery." clients who mind will pass. the ones who hire you won't be surprised later
the proposal prompt and the 4 sample prompts are in the course below ↓
→ a 60-second animated explainer, $200. animation is still far off for AI → a $1,000/month podcast producer role with team calls
it flagged 2 traps:
→ a $250 office model that has to be a SketchUp file. Blender can't write one → a $4,750 dashboard job, vague brief, and the same title posted at least 5 times this week
the best clean pick: $150 per episode to edit a 2-hour podcast from Audacity projects. the client wrote they'd rather hire someone with less experience
the filter prompt is in the course below. paste your own 10 ↓
you don't need to be a Blender pro to sell 3D models anymore. 3D artists on Upwork charge $25-40 an hour
Claude Code builds the model in Blender from a Python script. it runs in the background, in the real-world units from the brief, and renders front, side, top and three-quarter views under the same lights
3 things to sell:
→ online stores: a product in 3D, plus a 36-frame turntable → indie games: low-poly assets → 3D printing: an STL file from a photo and a tape measure
the step that saves the job: the prompt reopens every exported file and checks it loads at the same size. a file that opens wrong is the fastest way to lose a client
copy the Blender prompt from the course below before your first 3D brief ↓
a podcast that drops every week is a client every week
US audio editors on Upwork charge $36-60 an hour, and audio is where Claude Fable 5.2 jumped most on Scale Labs' freelance test
what the client pays for, every episode:
→ hiss and hum removed → even levels between the voices → long silences cut → intro and outro music under the voice → exported at the loudness podcast apps expect
Claude Code does all of it with ffmpeg. if the client wants stems, Demucs splits the voice from the music
one thing to skip: AI voice-overs. robotic voices are on the test's list of failures
the cleanup prompt, loudness targets included, is in the course below ↓
lost your job ? here are 6 things you can sell on Upwork this week, and Claude Code makes the first draft of every one
the proof: Claude Fable 5.2 now finishes 41% of real freelance jobs on Scale Labs' Remote Labor Index. on Upwork's own rate pages, this kind of work pays $15 to $121 an hour
what to list:
→ podcast cleanup: hiss, hum, levels, cuts → vocal and instrument stems from one finished track → a clean floor plan from a phone photo of a hand sketch → product models for online stores, with a turntable render → printable 3D files from a photo and measurements → a monthly report from a client's spreadsheet export
no degree required. Claude Code runs the tools: ffmpeg and Demucs for sound, Blender for plans and 3D, Python for reports
the rate for each one, and its prompt, are in the article below ↓
then people opened the AI's files next to the freelancer's and asked one thing: would a client accept this?
a year ago the best agent got a yes on 2.5%. in july, 16%. on november 9, Claude Fable 5.2 got 41.3%
seconds 11 to 16 are the jump: the board goes from a few green tiles to almost half
where it got good, priced on Upwork's own rate pages:
→ audio cleanup and mixing: $36-60/hr in the US → floor plans and interiors: $15-28/hr, $41-91 in LA → 3D models: $17-40/hr → reports and dashboards: $25-45/hr
honest part: the other 59% still fails, and it fails where you can see it. child-like drawings. an 8-second video for an 8-minute brief. a house that changes shape between two 3D views
so the job you sell has 2 halves. Claude does the first pass, you open every file before the client does
and the score doubles about every 3.3 months. the head start is your first 3 reviews, so get them now
in the course below:
→ the 4 jobs and what each one pays → a Claude Code prompt per job → the check before the client sees it → where to sell and what to charge → your first 30 days
pick one of the 4 tonight. the course below has the prompt that delivers it ↓
real freelance jobs pay $632 on average. Claude now finishes 4 in 10
the number comes from Scale Labs and the Center for AI Safety. they took 240 jobs that 358 freelancers already did on Upwork, $143,991 worth, and gave AI the same brief and the same files
Claude now finishes 41% of real freelance jobs: which ones pay, and how to sell them (full course)
a year ago the best AI agent could finish 2.5% of real freelance jobs. on november 9, Claude Fable 5.2 finished 41.3%. the test is the Remote Labor Index from Scale Labs and the Center for AI Safety. it's 240 jobs that 358 verified freelancers already did on Upwork: sound design, floor plans, 3D models, data reports, game art. together the jobs are worth $143,991. the AI gets the same brief and the same input files the freelancer got. then trained reviewers open its files next to the freelancer's and answer one question: would a reasonable client accept this? for 41.3% of the jobs, Fable 5.2 got a yes. the next model, Opus 5.5, got 21.25%. GPT 6 Astra got 20.83%. the jobs are real work. the average one paid $632.60 and took a person 28.9 hours. the median paid $200 and took 11.5 hours. and the test let the AI spend up to $30 on a job. clients still pay for every one of them. the fee goes to whoever sends the finished files, and Claude now does 4 of every 10 of those jobs well enough to get accepted. Scale Labs said where Fable 5.2 jumped most: audio and music, architecture and interior design, and 3D modeling. it's still far off on industrial product design and animation. this course turns that into income. you pick one of 4 jobs Claude is strongest at, price it from Upwork's own rate pages, run it through Claude Code, check it the way the reviewers did, and sell it. every chapter ends with something you paste. • what 41% means, and what the other 59% looks like • sound: edits, mixes and effects • floor plans and interiors • 3D models • reports and charts • the check before the client sees anything • where to sell, and what to charge • your first 30 days tonight, open Upwork, search one of the 4 jobs, and save 5 briefs that match it. every chapter uses them. what 41% means, and what the other 59% looks like the score comes from 230 private jobs. 10 more are public, so anyone can see what a brief looks like. every agent gets up to $30 per job for its tokens and tools, plus models for images, speech and video. the test's workspace has Blender, GIMP and Audacity on it. three reviewers score every job, and the majority decides. they agree 94.4% of the time. the other 59% is where your fee comes from. when an agent fails, the reviewers see the same 4 problems: • poor quality, like child-like drawings: 45.6% of failures • incomplete work, like an 8-second video for a brief that asked for 8 minutes: 35.7% • broken or wrong files: 17.6% • a house that changes shape between two 3D views: 14.8% one failed job can have more than one of these. and every one of them shows the moment you open the file. so the work you sell has two parts. Claude does the first pass. you open every file before the client does. the pace is the other reason to start now. the RLI site puts the doubling time at about 3.3 months. in july the leader was Fable 5 at about 16%. four months later it's 41.3%. set up a workspace in Claude Code before the first job, so every job runs the same way: I'm starting a freelance delivery workspace. for each job, create a folder with: brief.md (the client's brief, word for word), inputs/ (their files), work/ (your drafts) and delivery/ (only files I approve). before you start any job, write work/plan.md: every deliverable, its file format, and the length, size or resolution the brief asks for. never put anything in delivery/ yourself. sound: edits, mixes and effects audio and music is where Fable 5.2 jumped most. even in the first round of the test, the jobs where AI matched people were mostly sound and images. the sound ones: effects for a retro video game, a vocal split from its backing track, voice-overs merged with intro and outro music. on Upwork, audio editors in the US charge $36 to $60 an hour, according to Upwork's own rate page. what to sell: • podcast and interview cleanup: hiss, hum, levels and cuts • intros and outros mixed under a voice-over • vocal and instrument stems from one finished track • sound effect packs for small games leave AI voice-overs out. "robotic or unnatural voice-overs" are on the researchers' list of failures. Claude Code runs the same tools an audio freelancer reaches for: ffmpeg for cuts, fades and loudness, and Demucs, an open-source model, for stems. job: [paste the brief]. the client's files are in inputs/. use ffmpeg for cuts, fades and loudness. if the brief asks for stems, install Demucs and split the track. match the length, format and loudness the brief asks for; if it gives no loudness, master podcasts to -16 LUFS and music to -14 LUFS. log every change with its timestamp in work/changes.md, then render the deliverables to work/. metric to watch: revision requests per job. one is normal. three means your intake questions are missing something. mistake to avoid: sending a file you haven't listened to from start to finish. floor plans and interiors architecture and interior design was the second big jump. one example job in the test: a floor plan from the client's sketch, furnishing options and photorealistic renders of the bathroom. it's also where agents used to fail in plain sight: floor plans that didn't match the sketch they were given. on Upwork, interior designers list at $15 to $28 an hour, and at $41 to $91 in Los Angeles. what to sell: • a clean 2D floor plan from a hand sketch or a phone photo, with every dimension • 2 or 3 furniture layouts for one room • renders of one room for a listing or a renovation pitch Claude Code can drive Blender from a Python script, so the renders run without you at the mouse. job: [paste the brief]. the sketch is in inputs/. first copy every dimension from the sketch into work/dimensions.md and stop so I can check them. after I confirm, draw the plan as SVG and PDF with exactly those dimensions. then build the room in Blender with a Python script in background mode and render [number] views at 1920x1080. check every render against dimensions.md and list any mismatch before you finish. metric to watch: every dimension on the plan matches the sketch. mistake to avoid: rendering before the client approves the plan. one moved wall means every render again. 3D models 3D modeling was the third. on Upwork, 3D modelers list at $17 to $30 an hour, and 3D artists and rendering artists at $25 to $40. what to sell: • product models for online stores, with a turntable render • low-poly assets for indie games • printable STL files from a photo and measurements the failure to look for shows up in 14.8% of failed jobs: a model that looks right from the front and changes from the side. job: [paste the brief]. build the model in Blender with a Python script, in the real-world units from the brief. render front, side, top and three-quarter views with the same lights, then a 36-frame turntable. export [glTF / FBX / STL], reopen every exported file, and confirm it loads with the same dimensions. put a one-page sheet in work/: dimensions, polygon count and the file list. metric to watch: every view agrees with the others. mistake to avoid: taking a brief that needs animation. Scale Labs lists animation as far from solved. reports and charts this one already worked in the first round of the test: agents did well on report writing and on code for interactive data visualization. on Upwork, data visualization specialists list at $25 to $45 an hour, and at $51 to $121 in the US. what to sell: • a monthly report from a client's spreadsheet export • an interactive dashboard as one HTML file • a market summary with every number linked to where it came from job: [paste the brief]. the data is in inputs/. before any chart, write work/checks.md: row counts, empty cells, duplicates and the date range. then build the report as [PDF / one HTML file with interactive charts]. every number in the text must come from the data or a named source. list each number and where it came from at the end of checks.md. metric to watch: every number in the report traces back to a row or a source. mistake to avoid: charts before checks. one duplicated row changes every total. the check before the client sees anything the test still uses people as reviewers for a reason. CAIS tried AI reviewers, and they were fooled by work that looked polished and was broken inside. so the check stays with you. Claude can do the first pass of it: review work/ against brief.md before delivery. for every deliverable: open it with the tool it's made for and confirm it loads; check the format and the length, size, resolution or dimensions the brief asks for; compare it with the other deliverables for consistency: same object, same proportions, same names. for each file, answer one question: would the client who wrote this brief accept it? write yes or no with the reason to work/review.md. move nothing to delivery/. then open every file yourself, in the software it was made for. the files you approve go to delivery/. where to sell, and what to charge start on Upwork. the test's 240 jobs came from freelancers there, and its fee is 0% to 15% of each contract. price each job as a fixed deliverable. the median job in the test paid $200 for 11.5 hours of a person's time. start your first offers near that, and raise the price after your first 3 reviews. your profile needs 3 samples per offer. make them from the 5 briefs you saved tonight. before any proposal, filter the job posts. paste 10 of them at once: I'm picking freelance jobs to deliver with Claude. here are 10 Upwork job posts: [paste]. for each one, list the deliverables and their file formats, and name its type: audio, floor plans and interiors, 3D models, reports and charts, or none. mark it skip if it needs animation, industrial product design, calls with the client, or results that take months, like SEO. rank the rest by budget per deliverable, best first. say how you work in every proposal. one line is enough: "I make the first draft with Claude and check every file by hand before delivery." clients who mind will pass, and the ones who hire you won't be surprised later. write a proposal for this job: [paste the job post]. 120 words max. first line: the deliverable and the deadline, in the client's own words. then one sample from my portfolio that matches, with its link: [link]. then the 3 questions I need answered to start. end with a fixed price of [$] and what it includes. no greetings and no "I'm excited". your first 30 days week 1: build 3 samples for one job type from the briefs you saved. week 2: send 10 proposals a day, only to briefs your samples match. week 3: deliver, and log every revision request. they show you which intake questions to add. week 4: raise the price on the job type with the fewest revisions. what it costs: Claude Pro now includes Fable for up to 50% of your weekly usage. on the API, Fable 5.2 is $8 per million input tokens and $40 per million output tokens. the test capped each job at $30. what kills this: • selling the other 59%. animation and industrial product design are still mostly failures. • jobs the test left out: anything that needs calls with the client, physical work, or results you only see months later, like SEO. the 41% says nothing about them. • AI voice-overs. • skipping the check. poor quality is the most common failure, and a client sees it in the first minute. the setup on one page TEST Remote Labor Index: 240 real Upwork jobs worth $143,991, median $200 SCORE Fable 5.2 41.3%, Opus 5.5 21.25%, GPT 6 Astra 20.83%, a year ago 2.5% STRONGEST audio and music, architecture and interior design, 3D modeling WEAKEST industrial product design, animation RATES US audio $36-60/hr, interiors $15-28/hr, 3D $17-40/hr, data viz $25-45/hr FILTER 10 job posts at once; skip animation, product design, calls, SEO CHECK open every file in its own software: would the client accept it? SELL Upwork, fee 0-15%, fixed price per job, start near $200 WEEK 1 3 samples for one job type save this block. tonight, take one of the 5 briefs you saved and run it through the workspace prompt and the prompt for its job. open what comes back in the software it's made for. that's your first sample. bookmark this before you open Upwork tonight. you'll want the prompts when the first brief comes in.
the priciest Claude model came out at half the price per task
Fable 5.2 costs twice what Opus 5.5 does per token. on FrontierCode 2.0, Fable at high scored 45.3%, Opus at max 45.5%, and Fable did it for roughly half the cost per task
so before you push Opus past high on a hard task, run it on Fable at a lower effort
that's one of Anthropic's own numbers i put into the course below. a few more:
→ 40 turns up to 120K context: ~2.8M tokens sent → the same task in 25 turns: ~1.75M → 30 turns at 150K: $0.90 in cache reads alone → medium effort: 2.5 points under high, ~70% of the cost → 2 of 20 problems ate 43% of the spend
honestly the cheapest win in there is one command: /claude-api prompt-audit cut another 9% off Anthropic's support benchmark
every chapter ends with something you paste into Claude Code. start with "where the money goes" ↓
how to stop paying Opus prices for Haiku work in Claude Code (full course)
Claude Code reads your files on Opus now. the built-in Explore subagent, the one Claude sends to search your codebase, used to run on Haiku. in current versions it runs on your session's model. on the default setup that's Opus 5.5: $4 per million input tokens, against $0.10 for Haiku 5.5. that's one setting. Anthropic published the numbers behind the rest in its november 9 guide to picking a Claude model, and in a september post on what a task costs on Opus 5.5: • every task at low effort, with only the failures re-run at high, finished about 97% of tasks at $0.17 each. every task at high finished 95.3% at $0.29. • an Opus lead with up to 25 Sonnet workers cost about a third less than Opus alone, with about the same score. • on an API key, a 6-minute coffee break at 120K tokens of context turns the next $0.02 cache read into a $0.60 write. • on one 20-problem benchmark, 2 problems carried 43% of the spend. this course turns those numbers into settings. every chapter ends with something you paste into Claude Code, and you'll spend less after each one: • where the money goes: turns, cache, output and model • put Explore and the other readers on Haiku • set effort before you switch models • keep the cache warm • send less on every turn • pick the model by the job • a lead and cheap workers • measure it on your own work if you only have 30 seconds, these 5 lines are the whole course: make a subagent named Explore with model: haiku, and put every subagent that only reads on Haiku. start at medium effort. run batches at low and re-run only the failures at high. on an API key, compact before a break, never after it. keep CLAUDE.md under 200 lines and turn off the MCP servers you don't use. keep Opus for the decisions and the code edits, and check /usage after every real task. where the money goes a Claude Code task is a loop: read the conversation, call a tool, read the result, go again. every trip round the loop is one request, and 4 things set its price. • turns. every turn resends the whole conversation. in Anthropic's example, a task that grows from 20K to 120K tokens of context over 40 turns sends about 2.8M input tokens. the same task in 25 turns sends about 1.75M. • cache reads. most of what a turn resends was already sent on the turn before, so it bills as a cache read: $0.20 per million on Opus 5.5, a twentieth of the $4 input price. those 2.8M tokens cost $11.20 with no cache, $1.62 at a 90% hit rate and about $0.99 at 96%. • output. $20 per million on Opus 5.5, 100 times a cache read. thinking bills as output, even when Claude Code only shows you a summary. 60K output tokens cost $1.20, as much as 6M tokens read from cache. • model. it sets the price of every token, and every subagent that inherits the model inherits its price. at the end of your next real task, run /usage and read 3 lines: cache share: high on a long session. low means a long pause, a model switch or an MCP server connected partway through. output against input: a lot of output on a small change means the effort is too high or the model is retrying. total input against the size of the conversation: many times bigger means many turns. read the session and find the loop. you get the one line of your bill to fix first. fewer turns and a warm cache save more than any discount. put Explore and the other readers on Haiku a subagent is a helper Claude starts for a side job. it works in its own context window and hands back a summary, and it pays for its own tokens at its own model's price. Claude Code's built-in subagents, per the docs: • Explore searches your codebase, read-only. it runs on your session's model. when your session runs Fable, Explore drops to Opus on a Claude subscription, an Anthropic Console account or a gateway, and stays on Fable on Bedrock, Google Cloud, Foundry, Claude Platform on AWS and a Claude apps gateway. • Plan does research in plan mode. it inherits your session's model. • general-purpose explores and edits. it inherits too. a file named Explore in your agents folder replaces the built-in one and keeps its own model. Anthropic's guide says to do exactly that. save this as ~/.claude/agents/Explore.md for every project, or .claude/agents/Explore.md for one: --- name: Explore description: Fast read-only agent for searching and understanding a codebase. Use it to find files, search code and answer "where is this" questions. tools: Read, Grep, Glob model: haiku omitClaudeMd: true --- Search and read only. Never create or edit files. Answer with file paths, line numbers and a short summary of what you found. omitClaudeMd starts it without your CLAUDE.md, the way the built-in Explore starts. restart Claude Code if the agents folder didn't exist before, and run claude update: on the Anthropic API the haiku alias points to Haiku 5.5 from v2.1.293. on Bedrock, Google Cloud, Foundry and Claude Platform on AWS it still means Haiku 4.5. do the same for every helper that only reads logs, test output or search results. this one is Anthropic's own example: --- name: log-reader description: Reads test output and logs, and reports each failing case. Use after a test run. tools: Read, Grep, Glob, Bash model: haiku --- Read the logs you're given. For each failure, report the file, the test name and the first error line. Don't edit any files. to put every subagent on one model, set the CLAUDE_CODE_SUBAGENT_MODEL environment variable. a model named in a subagent's file wins over the variable. keep code edits and judgment calls on your main model. a small model that misreads a search result sends the main one to the wrong file, and the main one pays for the detour. you get search, logs and test output read at $0.10 per million input tokens instead of $4. run /tasks the next time Claude delegates, and you'll see which model each subagent is on. one file per reader, and reading stops costing Opus prices. set effort before you switch models effort sets how much the model thinks, writes and calls tools on every turn. Opus 5.5 has low, medium, high and xhigh, plus max for a single session. medium is the default in Claude Code. Anthropic measured it on a SWE-bench Pro subset with Opus 5.5: • medium: about 2.5 points below high, for about 70% of the cost. • low: about 8 points below high, for about a third of the cost. • xhigh: about 1.4 points above high, for 2.5 times the cost. then the run that beat all of them: everything at low, and only the failures re-run at high. about 97% of tasks done at $0.17 each, against 95.3% at $0.29 with every task at high. it only works when Claude can check its own work: a test, a build or a script that calls the endpoint. a check costs one turn and its output. more effort adds thinking to every turn. when a model isn't good enough, Anthropic's guide gives this order: 1. give it a way to verify its work. 2. raise effort one level. 3. move to the next model up, at a lower effort than you used on the smaller one. for a batch of tasks, run /effort low and paste: do every task in todo.md, one at a time. after each one, run its test. write the tasks whose tests fail to failed.md, each with its first error line. change nothing outside this repo and push nothing. then run /effort high and paste: redo only the tasks in failed.md and run their tests again. tell me which ones still fail. push nothing. you get a cheap first pass over everything, and high effort only where the first pass failed. with an API key or a subscription, changing effort keeps your cache. on Bedrock, Google Cloud's Agent Platform or a gateway it clears the cache, so change it at a break there. low first, high on the failures, and you pay for thinking only where it changes the result. keep the cache warm the cache holds the part of the conversation Claude Code doesn't pay full price to resend. on Opus 5.5 a cache read costs 5% of a fresh input token. a cache write costs 1.25 times the input price for a 5-minute cache, and 2 times for an hour. how long it lives depends on how you pay: an hour on a Claude subscription, 5 minutes on an API key or a cloud provider, and 5 minutes once a subscription draws on usage credits. that's the coffee break. at 120K tokens of context, a read costs about $0.02 and a fresh 5-minute write about $0.60. pause for 6 minutes on an API key, and your next turn pays the write. these also make the next turn pay a write: • switching models: the new model starts with an empty cache. • connecting or disconnecting an MCP server partway through. • turning on fast mode for the first time in a conversation. • compaction, which rewrites the history the cache matched. • changing effort on Bedrock, Google Cloud's Agent Platform or a gateway. set those up when the session starts, and leave them alone while it works. compact at a natural break, while the cache is still warm. at 150K tokens a /compact costs about $0.25 and saves about $0.025 on every later turn, so it pays for itself in about 10 turns. after a break longer than the cache lifetime, the same /compact reads the whole conversation again: about $0.75 at 150K. /clear costs nothing, so use it between unrelated tasks. /rewind goes back to an earlier turn that's still cached, when you want to drop a path. before you step away, paste: /compact keep the failing test names, the files we changed and the next step you get a short conversation that's still cached when you come back. compact before the coffee, never after it. send less on every turn every turn resends everything before it. at 20K tokens of context, a turn's cache read costs about $0.004 on Opus 5.5. at 150K it's about $0.03, so 30 turns spend $0.90 on reads alone, against about $0.12 at 20K. 3 things load before you type: • CLAUDE.md loads into every session, and every turn resends it. Anthropic's costs docs say to keep it under 200 lines. • MCP servers. only the tool names and server instructions load at the start, and a full definition loads when its tool is used. run /mcp and turn off the servers you don't use. • old instructions. prompts written for an older model can make Opus 5.5 write more and repeat tool calls. on Anthropic's 44-ticket support benchmark, moving from Opus 4.8 to Opus 5.5 at low effort cut the cost by about 18%, and Claude Code's /claude-api prompt-audit command cut a further 9%. run /claude-api prompt-audit first, then paste: read my CLAUDE.md and every file it imports. propose a version under 200 lines: keep the commands to build and test, the rules Claude can't learn from the code, and anything that broke before. move the rest into docs/ and link to it from CLAUDE.md. show me the diff and change nothing until I say go. you get a shorter CLAUDE.md, the old ritual instructions gone, and a list of servers to switch off. a short context makes every one of your turns cheaper. pick the model by the job the price list, per million tokens: • Haiku 5.5: $0.10 in, $0.50 out for prompts up to 100K tokens, $0.50 and $2.50 above that. • Sonnet 5.5: $2 in, $10 out. • Opus 5.5: $4 in, $20 out. • Fable 5.2: $8 in, $40 out. Anthropic's starting points: • Haiku 5.5: classification, routing, extraction, and subagents that search files, read logs or summarize. • Sonnet 5.5: well-scoped coding like bug fixes and features built against a spec, chat, everyday documents, and agent tasks you run again and again. • Opus 5.5 at medium: everyday engineering and debugging, and anything you're unsure about. it's Claude Code's default. • Fable 5.2: major refactors and migrations, architecture, deep research, and leading many subagents. move up to it when Opus 5.5 at high still falls short. a higher price per token doesn't always mean a higher price per task. on FrontierCode 2.0, Fable 5.2 at high scored about level with Opus 5.5 at max, 45.3% against 45.5%, for roughly half the cost per task. before you push Opus past high on a hard task, run it on Fable at a lower effort. switch at a natural break. the cache belongs to the model that wrote it, so the first turn on a new model pays the write on the whole conversation. run /compact first, or start fresh with a short written plan. the opusplan alias plans with Opus and lets Sonnet make the edits. that puts your code changes on the cheaper model, the opposite of the reader setup above, so measure it on your own tasks before it becomes your default. paste: read todo.md. for each task, write the model and effort it should start on: Haiku for lookups and log reading, Sonnet for well-scoped fixes against a spec, Opus at medium for everyday work and anything unclear, Fable for migrations, big refactors and work that leads many subagents. save routing.md with one line per task and the reason. change no settings. you get routing.md: a model and an effort for every task before you start it. Opus by default, Haiku for reading, Fable when Opus at high falls short. a lead and cheap workers when a job won't fit in one context window, put the strongest model in charge and cheaper ones on the pieces. on an internal benchmark that searched about 22 million tokens of source code for defects, an Opus 5.5 lead with Sonnet 5.5 workers, up to 25 at a time, cost about a third less than Opus 5.5 alone at its default effort, and scored about the same. skip it when the work is one chain of dependent steps, or fits in one context window. there, the planning and merging cost more than they save. keep teams small. agent teams, an experimental feature, run every teammate as its own Claude Code instance, and Anthropic's costs docs put a team at about 7 times the tokens of a standard session when teammates run in plan mode. shut each teammate down when its part is done. the advisor tool pairs a cheap executor with a stronger advisor it can ask for help. in Anthropic's own table, none of the 4 pairings clearly beat its executor alone, so measure how often your executor asks before you pay for an advisor. paste: split [the job] into independent pieces that each fit in one context window. you're the lead: write the plan to plan.md, then hand each piece to a subagent on Sonnet with the list of files it may touch, and merge what comes back. no two pieces edit the same file. run the tests after each merge. show me plan.md before you start any subagent. you get plan.md, the pieces done in parallel on Sonnet, and Opus spent on the plan and the merges. the lead decides, and the workers read and type. measure it on your own work every number above comes from Anthropic's runs. yours depend on your codebase and your habits. • /usage at the end of a task shows tokens, the cache share and an estimated dollar cost at list price. /cost does the same. on a Pro, Max, Team or Enterprise plan, the dollar figure is a guide to how much work you did, and the same screen shows your usage bars. • /effort status shows your effort level, and /tasks shows which model each subagent runs on. • for a team, the Claude Code Analytics API gives estimated cost per user, and the Usage and Cost API splits spend by model and by cached against uncached tokens. • a baseline from Anthropic's costs docs: about $13 per developer per active day across enterprise deployments, and under $30 a day for 90% of users. pick one real task from your backlog and run it on 2 setups. paste this once per setup: I'm comparing 2 setups on the same task. the task: [task]. do it, run its test, and when you're done, tell me how many turns you took and what would have cut them. push nothing. after each run, check /usage, then /clear, switch with /model or /effort, and paste it again. you get your own cost per task on each setup. your own /usage is the number to trust. one paste sets up the Haiku readers, the shorter CLAUDE.md and the model routing. open Claude Code in your repo and paste: help me spend less in Claude Code, one step at a time. after each step, show me the change and wait for my "go". 1. create ~/.claude/agents/Explore.md: name Explore, a description that says it's a fast read-only search agent, tools Read, Grep, Glob, model: haiku, omitClaudeMd: true, and a body that says search and read only, never create or edit files. 2. create .claude/agents/log-reader.md with model: haiku. it reads test output and logs and reports each failure with the file, the test name and the first error line, and never edits files. 3. read CLAUDE.md and every file it imports, and propose a version under 200 lines. move the rest into docs/. 4. list the MCP servers in my config and mark the ones this repo never uses. 5. read todo.md and write routing.md with a starting model and effort for each task. change no other settings, push nothing, and delete nothing without asking. after the paste, you have: • Explore and a log reader on Haiku. • a CLAUDE.md under 200 lines, with the rest in docs/. • a list of MCP servers to switch off. • routing.md: a model and an effort for every task. the setup on one page EXPLORE ~/.claude/agents/Explore.md, model: haiku, omitClaudeMd: true. READERS log and search subagents on haiku. code edits stay on the main model. EFFORT medium by default. batches at low, failures re-run at high. VERIFY a test or a build Claude can run, before you raise effort. CACHE subscription 1 hour, API key 5 minutes. /compact before a break. CONTEXT CLAUDE.md under 200 lines. unused MCP servers off. MODEL haiku for reading, sonnet for scoped work, opus daily, fable the hardest. TEAMS opus lead + sonnet workers only when it won't fit one context window. CHECK /usage after real tasks, /tasks for subagent models. screenshot this one. tonight, save the Explore file, restart Claude Code, and run /tasks the next time it searches your code.
the tool is CreativeClaw, run by one person in Israel with 446 followers on X. one connection plugs dozens of image, video, audio and 3D models into Claude, and its skills teach Claude which model to pick
august: $5,254 the last 30 days: $116,240
that's payment data, read from Polar by TrustMRR on november 9
Claude writes all day, and it still can't render a video, pull a competitor's ads or read your Search Console by itself. each of the 15 found one job Claude can't finish alone and sold the missing piece
7 seconds in, CreativeClaw plugs in last and takes almost half the bar
honestly i'd steal the pricing: $10 buys 1,000 credits, the first 100 are free with no card, and they never expire
everything you need to build one is in the article i'm quoting. each chapter ends with a prompt you paste into Claude Code: 02. find your gap in real complaints 03. a working connector in one evening 04. 10 real jobs before you charge 05. charge the way the winners do 06. get it in front of Claude users
someone in your field is about to sell Claude the piece it's missing. the article below shows you how to get there first ↓
CreativeClaw on TrustMRR, revenue read from Polar:
how one person made $116k in 30 days selling to Claude users (full course)
CreativeClaw is one person in Israel with 446 followers on X. it plugs dozens of image, video, audio and 3D models into Claude through one connection, and ships skills that teach Claude how to use them. users pay in credits: $10 buys 1,000, and one image costs 12. in august it made $5,254. in the last 30 days it made $116,240. the buyers are Claude users who hit a wall. Claude writes all day, and it still can't render the video, pull the ad library or read your Search Console by itself. a small group of founders sells exactly those missing pieces. every number in this course is payment data, read from each startup's Stripe, Polar or RevenueCat account by TrustMRR on november 9 and 10: • a stealth MCP that lets Claude pull competitors' ads and clone the winners made $27,252. in july it made $494. • Private Enterprise turns customer comments into ads inside Claude: $12,898, up every month since may. • Skillry, a library of skills for Claude Code that one person started on august 8: $12,051. • Headroom, a menu bar app that says it cuts Claude Code bills about in half: $3,060. its founder has it listed for sale at $199,999. each one found a job Claude couldn't finish alone and sold the missing piece. this course is that playbook. every chapter ends with a prompt you paste into Claude Code, and you'll have something working after each one: 01. what Claude users pay for: 4 kinds of products and their revenue 02. find a job Claude can't finish alone: gaps from real complaints 03. build the MCP server: a working connector in one evening 04. put it inside Claude: 10 real jobs before you charge 05. charge for it: credits, a monthly plan or one small price 06. get it in front of Claude users: the directory, plugins and X 07. the no-server route: sell skills 08. set it all up in one paste if you only have 30 seconds, these 5 lines are the whole course: pick one job Claude can't finish alone, for people who already pay for that job. build it as one remote MCP server in Claude Code, plus a skill that teaches Claude to use it. add it to your own Claude and run 10 real jobs before you charge. charge the way the winners do: credits with free ones to start, $5 to $105 a month, or one small price. list it where Claude users look, then post one real before and after on X. 01. what Claude users pay for every tool here gets paid because Claude stops at a wall its users hit every day. the paying tools fall into 4 kinds: 1. new powers for Claude. CreativeClaw adds images, video, audio and 3D: $116,240. Hypit gives Claude Code and Codex a runtime for making video, open source with paid model costs: $51,421. Agent Media turns Claude into a short-drama studio with the same cast every episode, from $49 a month: $3,550. 2. data Claude can't reach. the ad-tools MCP: $27,252. Private Enterprise, at $49.99 a month: $12,898. Search1API, web search for agents, run by one person: $7,024. Xquik, X data with an MCP, also one person: $5,768. Advanced GSC, Google Search Console inside Claude for SEOs at $15 to $105 a month: $4,486. Canopy API, Amazon data: $4,341. openbudget.sh, your bank accounts inside Claude at $5 a month: $2,492. 3. know-how, packed as skills. Skillry sells a library of skills for Claude Code at $9.99 a month: $12,051, from one person, in its third month. 4. tools around Claude Code itself. Headroom trims what Claude reads to cut the bill: $3,060. SessionWatcher shows token use in the menu bar for $6.99 once: $1,642. MacMD Viewer reads the markdown Claude writes, for $19.99: $1,375. Nowdex puts plan limits on an iPhone widget for $5.99: $1,332. the biggest ones sell into a job people paid for long before AI: ads, SEO, video, research. Claude does the work, and the tool hands it the one thing it was missing. pick your kind before you build. paste this into Claude Code: I know [your field] well. here are 4 kinds of tools Claude users pay for: new powers (media, video), data Claude can't reach (ads, SEO, Amazon, X, bank accounts), skills (packed know-how), and tools around Claude Code (cost, limits, output). for my field, give me 3 ideas per kind. for each idea: the job, who does it today, what they pay for it today, and the exact data source or API Claude would need. change nothing on my computer. you get 12 ideas, each tied to a job someone already pays for. money follows the job, so pick the job first. 02. find a job Claude can't finish alone the best gap is a sentence your buyers already type: "Claude can't..." a gap is worth building when people ask for it out loud, and they already pay for that job without Claude. turn on web search in Claude Code and paste: search Reddit (r/ClaudeAI, r/ClaudeCode and the subreddit for [your field]), X and GitHub issues from the last 60 days for posts where someone says Claude can't do a task in [your field], or asks for a tool, connector or MCP to do it. save gaps.md: one line per gap with the job, the exact quote, the link, the date, and the paid tool those people use today without Claude. group repeats and sort by how many people asked. read only. sign up for nothing and post nothing. you get gaps.md: real asks with links, sorted by how many people want the same thing. a gap 10 people asked for this month beats any idea you came up with alone. 03. build the MCP server an MCP server is a small web service that hands Claude new tools. it tells Claude what each tool does, Claude calls it, and your code does the work. Anthropic's connector quickstart builds one in TypeScript: the official @modelcontextprotocol/sdk, an McpServer with registerTool, served over Streamable HTTP at POST /mcp. build 3 things in from the first day: • every tool gets a title and a readOnlyHint or destructiveHint. Anthropic's directory asks for them, and its review rejects tools that mix reading and writing. • each tool answers fast and short: Claude takes about 150k characters per result and waits 240 seconds per call. • a skill ships with the server. CreativeClaw's skills tell Claude which model to pick and how to write the prompt, so the first try comes out right. paste this into Claude Code in an empty folder: build a remote MCP server in this folder, following claude.com/docs/connectors/building/quickstart. use TypeScript, @modelcontextprotocol/sdk and zod, and serve it over Streamable HTTP at POST /mcp on port 3000. it wraps [the API or data source from gaps.md] and has 2 tools: one that only reads (readOnlyHint true) and one that does the job (destructiveHint false). give every tool a title and a description that says when Claude should use it. read the API key from an environment variable, never from the code. then write SKILL.md: when to use these tools, in what order, and 3 example requests. run the server and test it with: npx @modelcontextprotocol/inspector --cli --transport http --method tools/list show me the tool list. deploy nothing. you get a server that answers on your laptop, its tool list from the inspector, and a skill that teaches Claude to use it. one evening, 2 tools and a skill, and the missing piece exists. 04. put it inside Claude test it where your buyers will use it, before you charge a cent. in Claude Code, one line adds it: claude mcp add --transport http [name] in the Claude app, open Customize > Connectors and add your server's URL. it works on every plan, Free included. a server on your laptop needs a public URL first, so run a tunnel or deploy it. then run real jobs through it: run 10 real jobs from gaps.md through my connector, one at a time. for each, write to tests.md: the request, which tools you called, how long it took, and whether the result was good enough to pay for. where you picked the wrong tool, rewrite that tool's description. change nothing outside this folder. you get tests.md with 10 runs, and the before and after you'll post in chapter 06. 10 real jobs in your own Claude, and you know what you're selling. 05. charge for it the tools that get paid charge in 3 ways: • credits. CreativeClaw sells $10 for 1,000 credits, gives 100 free with no card, and the credits never expire. Xquik starts pay-as-you-go at $10 and offers $20, $99 and $199 plans where unused credits carry over. credits fit anything with a cost per call, like media models or data. • a monthly plan. Advanced GSC charges $15, $40 or $105 a month. Private Enterprise charges $49.99, or $99.99 for a team. Pear, which brings iCloud and Microsoft 365 into Claude, charges $7.99. • one small price. SessionWatcher costs $6.99, Nowdex $5.99, MacMD Viewer $19.99. cnvs charges $199 once. wire it the simple way first. sell the credits or the plan on your own site with Stripe or Polar checkout: CreativeClaw and Headroom take payments through Polar, most of the others through Stripe. your server checks each call against the buyer's balance. Claude's connectors sign users in with OAuth: the buyer logs in once, and every call carries their account. plain API keys in headers are still in beta. per-call payments exist too. Stripe has an experimental guide where a tool answers with a payment link, and Cloudflare's Agents SDK has an example that charges $0.01 a call. start with credits, the way the $116k tool does. paste: add payments to this server. users buy credits on a simple page with [Stripe or Polar] checkout: 100 free credits on signup, then $10 for 1,000. every tool call costs [N] credits and stops with a clear message when the balance is empty. sign users in with OAuth as described in claude.com/docs/connectors/building/authentication. use test-mode keys only, and show me every file before you write it. you get a checkout in test mode, a balance per user, and a server that stops at zero. free credits to start and a price per call, and Claude users pay you the way they already pay CreativeClaw. 06. get it in front of Claude users Anthropic runs the shelf inside Claude itself: the Connectors Directory. • submit at claude.ai/directory/manage, under Submit new and MCP connector. you need a paid Claude plan. • you need a remote HTTPS server, OAuth (or no sign-in for public data), docs, a privacy policy, a support contact, an icon and a test account with real data. • an automatic scan comes first, then a Community listing. listings rank by usage, and any of them can show up inside a chat as a suggested connector. • read the policy before you build. the directory doesn't list tools that move money or crypto, generate AI images, video or audio, or sell ads and paid placements. Claude Code has its own shelf. put a .claude-plugin/marketplace.json in a public GitHub repo, and anyone can add it with claude plugin marketplace add owner/repo, then claude plugin install. the same portal takes plugins for Anthropic's community directory, which lists 2,283 of them. a plugin can carry your connector and your skill together. the official MCP Registry keeps your server's listing for other directories to pick up: mcp-publisher init, login, publish. then post where the founders say their buyers came from. Skillry names X, Threads, YouTube and search. Hypit names X and Discord. Headroom names search, Reddit, X, Hacker News and Product Hunt. paste: write my launch kit into launch.md: a directory description under 50 words with no claim I can't prove, an outline for the privacy policy and support page, a README for the plugin repo, the .claude-plugin/marketplace.json, and an X post that shows one job from tests.md before and after, with the real numbers. publish nothing. you get every listing text and your first post, ready to send. one listing where Claude users browse, and one post with a real before and after. 07. the no-server route: sell skills a skill is a folder with a SKILL.md that teaches Claude a job: when to use it, the steps and examples. it's an open standard since december 2025. in the Claude app, anyone can upload a skill as a ZIP under Customize > Skills, with code execution on. Anthropic's directory doesn't list skills alone, so they travel inside a plugin. Skillry sells a whole library: free skills, plus Premium at $9.99 a month, $79 a year or $169 for life. one person, $12,051 in the last 30 days. paste: turn my best workflow into an Agent Skill. ask me 5 questions about [the job], then write [skill-name]/SKILL.md with a name, a one-line description of when to use it, the steps, and 2 worked examples. add any template files it needs, then zip the folder so I can upload it under Customize > Skills. change nothing outside this folder. you get a skill folder and a ZIP you can install, sell or put in your plugin. one workflow, written once, and it installs in any Claude. 08. set it all up in one paste one message in Claude Code runs chapters 02 to 07 in order. open Claude Code in an empty folder and paste: build my first paid tool for Claude users in this folder, one step at a time. after each step, show me the result and wait for my "go". 1. research: search Reddit, X and GitHub issues from the last 60 days for things people in [your field] say Claude can't do. save gaps.md with quotes, links and the paid tool they use today. show me the top 3 and let me pick one. 2. server: build a remote MCP server for that gap, following claude.com/docs/connectors/building/quickstart: TypeScript, @modelcontextprotocol/sdk, Streamable HTTP at POST /mcp, 2 tools with titles and a readOnlyHint or destructiveHint, keys from environment variables. 3. skill: write SKILL.md that tells Claude when and how to use the tools. 4. test: list the tools with the MCP Inspector, add the server with claude mcp add --transport http, run 5 real jobs and log them in tests.md. 5. payments: credits with [Stripe or Polar] in test mode, 100 free on signup and a price per call, with OAuth sign-in per claude.com/docs/connectors/building/authentication. 6. launch: write launch.md with the directory description, the README, the .claude-plugin/marketplace.json and an X post built from tests.md. deploy nothing, publish nothing, and use test-mode keys only. after the paste, you have: • gaps.md: the job, with proof that people ask for it. • a working MCP server and the skill that drives it. • tests.md: real jobs, timed, with the results. • a checkout in test mode and a credit balance per user. • launch.md: the listing, the plugin files and your first post. the setup on one page JOB one job Claude can't finish alone, for people who already pay for it. PROOF gaps.md: real asks, links, the paid tool they use today. SERVER remote MCP, TypeScript SDK, POST /mcp, 2 tools, title + read or write hint. SKILL SKILL.md that tells Claude when and how to call your tools. TEST Inspector first, then 10 real jobs in your own Claude. PRICE credits ($10 = 1,000, 100 free), $5 to $105 a month, or one small price. PAY Stripe or Polar checkout, OAuth sign-in, test mode first. LIST Connectors Directory (check the policy), plugin repo, MCP Registry. LAUNCH one real before and after on X. screenshot this one. tonight, write down 3 jobs in your field that Claude can't finish alone, then paste the chapter 02 prompt and see which one people already ask for.
it's the built-in Explore subagent, the one Claude sends to search your codebase. it used to run on Haiku. now it runs on your session's model, and on the default setup that's Opus 5.5
→ Opus 5.5: $4 in, $20 out per million tokens → Haiku 5.5: $0.10 in, $0.50 out (prompts under 100K)
Anthropic's guide from nov 9 says to fix it yourself: a subagent named Explore with model: haiku replaces the built-in one. on a plan your limits go further, on an API key it's dollars
the same guide had 2 numbers i didn't expect. Opus 5.5 on a SWE-bench Pro subset:
→ every task at high effort: 95.3% done, $0.29 a task → every task at low, failures re-run at high: ~97%, $0.17
cheaper and better at the same time
and an Opus lead with up to 25 Sonnet workers came out a third cheaper than Opus alone, with the same score
one more from their cost post: on an API key the cache lives 5 minutes. a 6-minute coffee break at 120K of context turns the next $0.02 cache read into a $0.60 write
type /tasks in Claude Code to see which model each subagent is on
the Explore file and the low-then-high setup are in the first reply ↓
Prompt:
"save this as ~/.claude/agents/Explore.md (or .claude/agents/Explore.md for one project), then restart Claude Code:
--- name: Explore description: Fast read-only agent for searching and understanding a codebase. Use it to find files, search code and answer "where is this" questions. tools: Read, Grep, Glob model: haiku omitClaudeMd: true ---
Search and read only. Never create or edit files. Answer with file paths, line numbers and a short summary of what you found.
the haiku alias points to Haiku 5.5 from Claude Code v2.1.293, so run claude update first. next time Claude explores, /tasks should show Explore on Haiku
low-then-high for a batch of tasks: 1. /effort low, then: "do every task in todo.md, run its test after each one and write the ones that fail to failed.md" 2. /effort high, then: "redo only the tasks in failed.md, run their tests again" 3. /usage to see what it cost"
Part 1: https://www.binance.com/square/post/387235596799959
"Set up this repo so a small team of Claude Code agents can work in parallel without editing the same files. Copy the 5-table setup from Anthropic's 1,000-agent Fermat run:
1. Create .team/team.db (SQLite) with 5 tables: - announce: the lead's orders to everyone - assign: who owns which task - notes: progress, questions and "I'm free" posts - subtasks: the to-do list, with the files each task may touch. A task belongs to the first agent whose claim succeeds: UPDATE subtasks SET claimed_by = ? WHERE id = ? AND claimed_by IS NULL, then check that exactly one row changed - landed: finished work, with the branch, the commit and whether the tests passed
2. Write 4 small scripts in .team/: claim, note, land and status, one command each.
3. Write .team/HELPER.md, the loop every helper follows: read announce, claim one task, work only in your own git worktree and branch, touch only that task's files, run the tests, merge into main only with green tests, log it in landed, post a note, claim the next task. If a task is too big, split it into new subtasks instead of giving up.
4. Write .team/LEAD.md: split the goal into subtasks, list the files each one may touch, never leave two open tasks on the same file, read notes every few minutes and move free helpers to whatever is stuck.
Don't start any agents. When it's ready, show me the files and the exact commands to start 1 lead and 3 helpers, each in its own git worktree."
Part 1: https://www.binance.com/square/post/387073609143735
the lead agent parked the 47 at first. about 70 minutes in the other 13 were done, so it wrote "there is no reason to idle" and sent everyone back at the impossible ones
this is Anthropic's run with an early Claude Fable 5.2, from their blog on nov 9. 1 lead, 999 helpers, and every step of the proof checked by a computer in Lean
what i keep rereading is how 1,000 agents worked on one proof without stepping on each other
they had no chat. no messaging tool at all
each agent got its own sandbox with no internet and its own Git branch. a separate job merged the branches into main
and one shared Postgres database. in the first 10 minutes the lead made 5 tables:
→ announce: its orders to everyone → assign: who owns which statement → notes: an open board for progress → subtasks: a to-do list, first claim owns the task → landed: a log of finished work
by hour 30 the tables had taken 36,612 writes and 311,734 reads. nearly every write was a note or a task update
the hardest piece, Langlands–Tunnell, had a captain who gave it under a 1% chance. the lead put about 750 agents on it anyway and wrote "Honest odds are low."
they split it into a tree of 2,418 tasks, 10 levels deep, and proved it at hour 28.4. the theorem landed 18 minutes later
the same thing breaks at 3 agents. two Claude Code agents in one repo grab the same task and edit the same files
so give every agent its own worktree, keep one tasks table, and let the first claim win
the prompt that sets this up in your repo is in the first reply ↓
Part 1: https://www.binance.com/square/post/387073609143735