How software actually gets built — for people who don't write code.
Every hour of setup done at home is an hour of building in the room. None of it is hard. All of it is slow if forty people do it at once.
warp.dev. Your terminal. Free.nodejs.org. Take the version it recommends. Claude Code needs it.npm install -g @anthropic-ai/claude-code — one line, once, forever.claude and press enter. Sign in when it asks.claude, ask it "what can you do?" and get an answer back. If you get there, the hard part is behind you.All free tiers, about two minutes each. Do them now so day 3 is building rather than signing up.
Every software product fills the same ten boxes.
A booking site. A client portal. An internal tool. Different names in each box — same ten boxes.
Learn the boxes and you can read any company's stack in five minutes — including one you've never seen.
A real web app with accounts, a database and payments — not a brochure site. Costs close to nothing until you have customers. Render joins later, the first time something needs to run on a schedule.
By 4pm you have a working URL on the internet that you built — and you've watched an agent fix its own mistake.
A model can only do one thing: take text in, put text out.
It can't open a file, visit a website or send an email. Left alone it's a very well-read person locked in a room with no phone.
The model is the engine.
The harness is the car.
An engine on a workshop floor is impressive and useless. The car is the steering, the pedals, the brakes — the parts that turn combustion into going somewhere.
CLAUDE.md, your skills — every session.Claude Code is a harness. Cursor is a harness. So is the Claude app on your phone.
Claude Code and the Claude app are the same model.
Everything that makes one more capable than the other is harness. Most of the gap between a demo and something that actually works is harness, not model — and it's the part you control.
The difference is where it lives — which decides how much it's allowed to touch.
Lovable, Bolt, Replit. Describe an app in a chat box. Nothing installed. Fastest to a demo — stuck inside their sandbox.
Cursor, Windsurf. Sits inside a code editor, helping with the file on screen. Built for people who read code all day — not our route.
Claude Code, Codex. Reads the whole project, changes many files, runs it, reads the errors, fixes them. Comes as a terminal tool or a desktop app — same agent either way.
Only a full agent can run your code, see what broke, and fix it — in a loop, without you clicking anything.
It works the way a contractor does. You describe the outcome; it comes back when the tests pass.
Same agent, same tools, same loop, same CLAUDE.md. The difference isn't capability — it's how many doors stay open.
Easier, friendlier, faster to start. Visual diffs, side-by-side panes, no black window. It is also a room with one door. Everything you learn is how Anthropic's app works.
Neutral ground. Every coding agent lives here — Claude Code, Codex, Gemini. Swapping is typing a different word in the same window.
Easier today, or optionality later.
The app gets a nervous beginner building an hour sooner. The terminal is the skill that still works when the best tool changes hands — and in this field it will, more than once.
We teach the terminal because it's where you end up anyway.
claude is one. That's the whole definition.Open Warp. Type claude. That's the entire ritual.
Reads your entire project, edits many files at once, runs commands and tests, and keeps going until it works.
Yes — at the shallowest layer in the whole stack.
You're renting the typist, not the typing.
Your code and its history. Your database, hosting, logins, payments — every other box is untouched by which agent typed it. Your MCP servers, because MCP is an open protocol other agents speak. Most of your written instructions, because they're markdown.
Muscle memory. Tool-specific extras like skills and hooks. Some prompt tuning. Days of adjustment, not months of migration.
Portability isn't a tool you pick. It's a shape your work is in.
Choosing a weaker, model-neutral tool to stay free costs you capability today against a future where the leader changes every few months anyway. Keeping your work as plain files in git does the job for nothing — and you already do it.
npm install -g @anthropic-ai/claude-code — one line, once, forever.cd my-project.claude and sign in.Put a CLAUDE.md at the top of your project.
Anything in it is read at the start of every session — your conventions, what not to touch, how you like things done. Write it once. Stop repeating yourself forever.
CLAUDE.md in the repo. Committed — every teammate's agent reads it. How this project works: run the tests this way, this deploys there, never touch that.~/.claude/CLAUDE.md on your machine. Every project you open, nobody else sees it. How you work.SOUL.md, pulled in with one line: @SOUL.md. Who you are — voice, values, judgement. Not process.Project = facts about the code. Personal = preferences about you. Soul = who you are.
"Run tests with bin/dev test." Test: would a new teammate need this on day one?
"Numbered steps, one action each." Test: is this true of you on every project?
"Tell me bluntly, don't soften it." Test: would it still be true if you changed jobs?
Facts a new teammate would need on day one. Nothing about you.
Preferences that follow you between projects. Write it once on day 1 and every session after gets better.
The first two change how it works. The third changes how it sounds.
Without it you get competent writing that isn't yours — and you'll rewrite every email it drafts. One line, @SOUL.md, pulls the whole file in — which also keeps anything personal out of a repo your team can read.
You don't review it by reading it. You review it by seeing what changed and whether it still works.
If your laptop died tonight, is the work gone? This box is every file, and every version of every file, kept somewhere that isn't your machine.
There's one branch called main and it is the version that's live. Everything else is a branch off it — a named copy where you can change anything without affecting what customers see.
main. On a branch, the worst case is you delete it and nothing happened. On main, the worst case is your customers find out.A branch is a version of the history — a label, not a folder. A worktree is the folder of real files you can open. Switching branches doesn't make a folder; it rewrites the one you have.
A branch is which version. A worktree is where it's laid out.
Connect GitHub once. Every push is live about thirty seconds later.
main → the live site updates automatically.The line isn't frontend versus backend. It's this: Vercel runs your code when someone visits. Render runs your code when nobody is visiting.
An always-on backend that answers requests.
Runs on a schedule, then stops.
Runs constantly, chewing through a queue.
By 4pm your app remembers things, knows who's logged in, and has taken a test payment.
The agent holds only so much at once. Your CLAUDE.md, every file it reads, every command it runs, and the whole conversation so far all compete for that space.
A conversation is expensive memory.
A file is cheap memory.
Every message re-sends the whole context — so a bloated conversation is vaguer and costs more on every turn. Anything you'll need again belongs in a file the agent can re-read, not in a chat you're nursing along.
CLAUDE.md" — one line, survives every compact.A Postgres database plus file storage and an automatic API, with a dashboard where you can see your data like a spreadsheet.
Drop-in sign-up and login screens that already look good, plus profiles, social logins and teams.
Clerk answers "who is this?"
Your database answers "what are they allowed to see?"
Two different jobs. Clerk logging someone in does not stop them reading another customer's data. You still have to write that rule.
It scales from a payment link you make in a dashboard in ten minutes — no code, no developer — all the way to subscriptions and in-person card readers.
4242 4242 4242 4242.Someone signs up. Someone resets a password. A booking is confirmed. Your app has to send that — and it has to land in the inbox, not in spam.
Software you build is not the same as software you run.
Your CRM, your forms, your scheduling link, your chat widget — HubSpot, Tally, Cal.com, Intercom — are bought, logged into and configured. They matter enormously and none of them are in these ten boxes. Every box here is a component you wire into your product.
By 4pm you have an automation doing a real job unattended, tests guarding it, and two minutes on stage.
A customer rings a normal phone number and talks to an agent. Here's every piece behind that.
Nothing in that list is exotic. It's five boxes, wired together.
A phone line, a transcriber, a model, some tools, a voice. Once you can name the pieces, "we built an AI receptionist" stops sounding like magic and starts sounding like an afternoon.
This is what people mean by "an AI agent" — not one product, three things arranged together.
The thinking. Box 07. Swappable.
The loop, the permissions, the memory. Claude Code.
The reach. Box 08 — this one.
When someone says they built an agent, these are the three things to ask about.
Instead of writing you one to copy and paste. It needs hands — and there are two kinds.
"When a form is submitted, add a row and send a Slack message." Same way every time. Zapier.
You describe an outcome. It works out which tools to use. MCP, Composio.
Rules for anything that must happen identically. Agents when the work needs judgement.
An API is a door. MCP is a door with a sign on it the AI can read.
MCP doesn't replace APIs — it sits on top of them. What's new isn't the access. It's that nobody hand-writes the glue any more.
These three names sound like rival products. Each one sits on top of the one above it.
No AI in the loop? Just use the API. Agent deciding? MCP. Don't want to write it? Composio.
A model knows what it was trained on. It doesn't know what happened this week, or anything specific about the company you just named. This is why agents make things up.
The model supplies judgement. These supply facts.
The categories are stable. The vendors churn.
An old supplier portal. A competitor's site. A government database with a search form. The fallback is blunt and it works: let the agent use the website the way a person would.
The robot that clicks through a site. You'll meet it again in box 10, testing your own.
Runs that browser in the cloud, steered in plain English. Handles staying logged in and looking like a real visitor.
"Find fifteen RV parks in Texas without online booking, and draft an intro email to each owner."
That's the whole job. It's one instruction.
A terminal runs one agent at a time. Soon the bottleneck is you, waiting for it. Run several at once and they overwrite each other — unless each gets its own copy.
A terminal. One agent at a time, in a window you can click and scroll like a normal app. Where you start.
Also a terminal — built to run several agents at once, each in its own worktree. Adds a diff view, GitHub and Linear, and a phone app.
Same kind of tool, different amount of it. Get fluent with one agent before reaching for many.
An agent can hire.
Instead of doing a big job itself, it breaks the job up, runs helpers in parallel, and collects what they found. One instruction becomes twenty agents working at once.
Four agents can read four hundred files between them and your window only receives four paragraphs. The context problem, solved by delegation instead of discipline.
Reading fans out cheaply. Writing needs isolation.
When AI writes the code, this box matters more, not less. You didn't write it — you can't eyeball it.
Your app needs secrets. They can't live in the code, because the code goes to GitHub — and GitHub repos have a way of becoming public.
NEXT_PUBLIC_… or VITE_… is compiled into the page and shipped to every visitor. Put a secret behind that prefix and you've published it.Reading a policy tells you what it was meant to do. Trying to break it tells you what it does.
A genuinely good habit that will find real things. It is not a security review.
Keys in code, missing RLS, a secret behind a public prefix, known-vulnerable dependencies.
It has no idea one park owner shouldn't see another's bookings. Most real breaches are business logic, not code bugs.
A key committed three weeks ago is already out. Scrapers watch public repos. Only rotating it helps.
An agent can check your work. It can't be the reason you're safe.
Rent the hard parts — logins from Clerk, payments from Stripe; their security team is bigger than your whole company. And when it's money, health data, or anything you'd have to write an apology email about, that's a paid review, not a prompt.
Half of what we taught you was built by strangers and given away.
Anthropic makes Claude Code. It didn't make most of what gets plugged into it. MCP servers, skills, agent setups, the templates you'll start from — written by people you'll never meet, published free, improved by whoever turns up.
awesome-mcp-servers are how you find one for a tool you already use.GitHub is where it is. X is where you hear about it.
The feed is built to eat your whole day. Treat it like a trade paper, not a group chat.
Installing an MCP server hands somebody else's program your Gmail, your database, your Stripe account. Most authors are honest. That isn't the same as safe.
Commits this month. More than one contributor. Issues that get answered. 8,000 stars and nothing since March is a museum.
If Stripe publishes a Stripe MCP server, use that — not the fan version with the nicer name and the bigger promises.
Point anything new at test keys or a throwaway account for a week. Then decide whether it gets the real ones.
Learn the ten boxes, and every new tool is just a name you can place.