
Clips | Streamers | Best Stream Moments part of @VectorX_Media
Joined April 2026
- Tweets1.6K
- Following64
- Followers5.5K
- Likes2K
A Chinese quant from Shanghai spent $3,200 on a Mac Studio M4 Max and built a bot on Claude + Obsidian that runs /autoresearch on a new asset class every night while he sleeps.
In the morning, on his desk sits a structured 40-page research report with citations, linked to everything he has read over the last 3 years.
In the evening he sets 1 topic: rare earth metals, Chinese REITs, Turkish sovereign bonds.
After that Claude works on its own: 3 to 5 rounds of web search, first a broad sweep, then filling in the gaps, then nailing down the key sources.
All of it turns into wiki pages with frontmatter and wikilinks, and contradictions with his old notes are automatically flagged in a separate callout.
By 6 AM the vault is 40 to 60 pages smarter. The quant wakes up, opens Obsidian, and sees a ready map of the topic linked to everything he has touched before.
He does not need to catch up to the market. The market is already sitting in his wiki.
8 hours of sleep now work for him. The market moves while you sleep. The second brain now does too.
How to build your own app with Claude Code and make $3K to $12K a month
You were told that launching a SaaS requires a cofounder, a $100K round, and six months of React.
In 2026 that is no longer true, and here is where the new line runs.
━━━━
Step 1. One file that changes everything
Install Claude Code via `npm i -g anthropic-ai/claude-code` and drop one file into the project root: `CLAUDE.md`.
This is not a README. This is a specification the model rereads before every code change.
In it you rigidly lock down:
— the stack: Next.js 15 + Supabase + Stripe Checkout + Vercel + Resend
— domain rules: "prices always in cents"
— prohibitions: "do not touch migrations without confirmation"
— definition of done: "a feature is ready only when it passes an e2e test in Playwright"
90% of the people complaining about "garbage AI code" simply never wrote this file.
━━━━
Step 2. One sentence, one working product
Then you say one sentence:
"Build an invoice tracking MVP for freelancers, wire up Stripe Checkout at $29 a month, deploy to Vercel."
Claude Code on its own:
— bootstraps the project
— sets up Row-Level Security in Supabase
— writes a webhook for `checkout.session.completed`
— runs Playwright
— opens a pull request in your repository
2 weeks of a junior developer's work turn into 40 minutes and about $4 in API tokens.
━━━━
Step 3. 3 techniques almost nobody looks at
Sub-agents. You run one agent on the backend, a second on the frontend, and a third on tests in parallel. They live in isolated `git worktree` folders and do not interfere with each other.
Hooks in `settings.json`. Before every commit the linter and `tsc --noEmit` run automatically. A broken build never reaches `main` again.
Your own slash commands in `~/.claude/commands/`. You describe `/ship`, `/review`, `/migrate` once, and reuse them across all your projects like your own DevOps department.
━━━━
Now about the million
The first $10K MRR is made not on a brilliant idea but on 3 boring steps:
1. Pick a niche where people already pay for a tool worse than yours: clinics, logistics, fitness trainers, amateur bookmakers.
2. Set the price at $29 to $49 a month from day one instead of a free model.
3. Rewrite your old pet project through Claude Code into a product that actually makes it to deployment.
340 paying users at $29 a month is mathematically your first million in ARR.
━━━━
The skill that makes you rich is not prompting. It is a `CLAUDE.md` written so precisely that the model assembles the same product twice in a row without drift.
Open the terminal tonight, and your engineering team turns into a process that does not sleep, does not ask for equity, and ships at 3 AM on a Tuesday.
I spent 11 years writing code at Google, 8 hours a day. Six months ago I replaced half of myself with a single markdown file, and now I work 2 hours a day and make $28,000 a month while I walk the dog and take care of personal stuff.
Sounds like a fairy tale? I thought the same thing right up until the evening when it all clicked.
I will tell you exactly what happened, because from the outside it looks like magic, but on the inside it is 3 boring steps.
The main insight I spent months working my way toward
I never had a problem with Claude itself. I had a problem with how I was explaining the task to it. Every time I wrote a long prompt, and it would start inventing things: pulling in libraries I never asked for, poking at files I had marked as do-not-touch, rewriting things that already worked. I was spending 2 hours trying to stop it, and another hour rolling back the extra stuff.
Out of 8 work hours, 3 went straight into the trash. Every. Single. Day.
The solution turned out to be almost insultingly simple.
One file in the project root, plain markdown, 4 rules inside:
Do not overcomplicate
Do not pull in extra dependencies
Do not rewrite what works
Always look at how the code around it is written first
I stopped repeating the same things on every new run. The model sees those rules automatically and behaves like a normal engineer, not a first-day intern.
The result showed up in the first week: the share of tasks Claude closed on the first try without my edits jumped from 30% to 85%. I checked the logs 3 times because I did not believe it.
After that I chopped my work into 15-minute cycles. Not 8-hour tasks like before, but small pieces the model can close before it loses context.
In one 15-minute window the system reads the task, finds the right files in the project, writes the code, runs the tests, and shows me a finished diff to approve. And 8 cycles in a row like that, while I handle my own stuff.
I left myself only 2 roles:
1st role: set the task and accept the result
2nd role: everything between the two is done by the system.
The most expensive mistake I used to make was trying to cram everything into the project at once: dozens of agents, other people's skill sets, a pile of tools "just in case." The limit that was supposed to last a full day got burned in an hour. In money: $40 down the drain in 60 minutes, and I did not even know what on.
Now I have exactly 4 agents connected, and each one only knows its own job:
1st: breaks the task into steps
2nd: writes the code step by step
3rd: catches errors before they reach me
4th: runs the tests and says "done" or "roll it back"
That is enough to close 8 out of 10 tasks without me stepping in. The system's daily spend dropped from the old $40 an hour to $6 to $8 for the whole day.
Now do the math yourself.
An hour of your time, let us say even just $30.
8 hours a day, 20 workdays a month, and half of those hours go into code you could have avoided writing by hand. Which means right now, while you are reading this post, $3,000 a month is quietly leaking out of your pocket, simply because nobody told you: between you and automation stands one file and one free evening.
And here is how the numbers grew for me after that evening:
Week 1: the first task closed without a single edit from me
Month 1: $4,000 on projects that had been sitting untouched for years
Month 3: $15,000 and my first vacation in 11 years without a work laptop in my bag
Month 6: a steady $28,000 a month, and I am relearning what a weekday Tuesday in the park looks like
I spent exactly that one evening. After that, the system did the work itself.





