Prompt 1
Get set up.
Where: Paste into claude.ai (free web version)
You'll get: A personalized setup checklist, Claude Desktop or Claude Code installed and working.
This prompt makes Claude into your install partner. It figures out your OS,
recommends the right install path (Claude Desktop for non-technical;
Claude Code in terminal if you've used a command line), installs the
dependencies for whatever you want to build, and verifies everything works.
I'm a non-technical builder who wants to start shipping production software using
Claude. I have never installed any developer tools before — or it's been so long I
need a fresh start. I'm using your free web interface right now because I haven't
installed anything locally yet.
I need you to walk me through getting fully set up. Here's how I want you to work
with me:
STEP 0 — CONFIRM WHAT I'M ON
Ask me three quick questions before we do anything else:
1. What operating system am I on? (Mac, Windows, or Linux — and if Mac, is it
Apple Silicon / M-series or older Intel? If you're not sure, I'll tell you
how to check.)
2. What's the rough shape of what I want to build first? (e.g., a marketing
website, a web app with users and a database, an internal tool or
automation, a content site, a mobile app, something else.) One sentence
is fine. We'll get more specific later.
3. Have I ever used a terminal / command line before? (Yes, comfortable / Yes,
scared of it / Never opened one.) There's no wrong answer — I'm asking so
you know how much to explain.
Wait for my answers before continuing. Don't bundle steps.
STEP 1 — PICK THE RIGHT CLAUDE TOOL FOR ME
Based on my OS and my comfort level, recommend ONE of these as my primary tool:
- Claude Desktop (recommended for Mac and Windows users who are nervous about
the terminal). It runs Claude with full agentic coding capability through a
desktop app — no terminal required for day-to-day use. Available on macOS
(Apple Silicon strongly preferred) and Windows 10/11 (x64 and ARM64). NOT
available on Linux as of 2026.
- Claude Code (the terminal CLI — recommended for Linux users, and for Mac /
Windows users who already work in Terminal or PowerShell or want to learn).
Runs inside any terminal. Same engine as Claude Desktop, different
interface. As of 2026 there are two install paths: (a) the official native
installer — no Node.js required, auto-updates; and (b) npm install (npm
install -g @anthropic-ai/claude-code) which requires Node.js 18 or higher.
Before you recommend, double-check the current canonical install instructions
by looking at what you know about Anthropic's official docs (claude.com/download
for Claude Desktop, code.claude.com for Claude Code). If anything in my
description above is out of date for today, use the current official instructions.
Then tell me which one you're recommending and WHY (one short paragraph). Wait
for me to say "go" before continuing.
STEP 2 — INSTALL THE CLAUDE TOOL
Walk me through installing it on my exact OS. Be ridiculously specific:
- Exact URL to visit, or exact command to run
- What I should see at each step (e.g., "you'll see a dialog asking for your
admin password — that's normal, type it in")
- What "done" looks like — what window, what text, what command to run to
verify it's working
- Common errors and how to fix them (permission denied, command not found,
download blocked by browser, etc.)
After install, have me sign in with my Anthropic account. If I don't have one,
walk me through creating one at claude.com — note that the free tier is enough
to start, but I'll likely want to upgrade to Claude Pro ($20/mo) or Max for
heavier use. Don't push the upgrade — just mention it as context.
Wait for me to confirm I'm signed in and the app/CLI works before continuing.
STEP 3 — ANTHROPIC API KEY (ONLY IF NEEDED)
If I picked Claude Desktop, I likely don't need a separate API key — the app
uses my account. Skip this step.
If I picked Claude Code CLI, walk me through getting an Anthropic API key from
console.anthropic.com if my chosen install path requires one. Tell me how to set
it as an environment variable on my OS (export ANTHROPIC_API_KEY=... on
Mac/Linux, setx on Windows). IMPORTANT: warn me to keep this key private and
never paste it into a shared chat or commit it to git.
STEP 4 — INSTALL THE DEPENDENCIES FOR WHAT I WANT TO BUILD
Based on my answer to question #2 in Step 0, pick a stack that fits. Some
rough defaults — but use your judgment based on what I told you:
- Marketing website (static, mostly content): Astro or plain HTML/CSS — just
need Node.js installed.
- Web app with users, a database, real interactivity: Ruby on Rails 8 (I
happen to love Rails for solo builders) OR Next.js if I'm leaning React /
JavaScript. Pick ONE and explain why.
- Internal tool or automation: Python with a simple framework like FastAPI,
or a Node.js script.
- Mobile app: React Native (Expo) or Flutter — note that mobile is harder
for a first project and ask if I want to start with a web version first.
- Content site / blog: Astro or a static site generator.
For my chosen stack, walk me through installing:
- The language runtime (Node, Ruby, Python, etc.) — use a version manager
when one exists (rbenv for Ruby, nvm for Node, pyenv for Python). Tell me
exactly which version to install (the current stable version as of today).
- A package manager if separate from the runtime (npm comes with Node;
Ruby uses bundler; Python uses pip).
- A database if I need one (Postgres is my default — show me how to install
it via Homebrew on Mac, the official installer on Windows, or apt on Linux).
- Git, if not already installed (Mac usually has it; Windows often doesn't).
- A code editor — VS Code is the easiest first choice. Free, runs everywhere,
plays nice with Claude Code.
For EACH dependency:
- The install command for my OS
- How to verify it's installed (e.g., "run `ruby --version` and you should
see 3.3.x or higher")
- What to do if the command isn't found after install
STEP 5 — MAKE MY FIRST PROJECT FOLDER
Have me create a folder for the project. Walk me through:
- Where to put it (I recommend a top-level folder like `~/dev/apps/` on
Mac/Linux or `C:\dev\apps\` on Windows so I don't end up with projects
scattered across Desktop)
- Initializing git inside the folder (`git init`)
- Creating a basic .gitignore appropriate to my stack
- Setting up a GitHub account if I don't have one (free, will need it later)
STEP 6 — VERIFY THE WHOLE THING WORKS
Have me run a one-line "does everything work?" test. Something like:
- Ruby: `ruby -e "puts 'Ruby works'"`
- Node: `node -e "console.log('Node works')"`
- Python: `python3 -c "print('Python works')"`
And confirm the Claude tool launches.
STEP 7 — OUTPUT MY PERSONALIZED CHECKLIST
At the very end, output a clean markdown document I can copy and save called
"My AIBBY Setup Checklist." Include:
- My OS
- The Claude tool I installed (Desktop or Code) and how to launch it
- The stack I chose and why
- Every dependency I installed with the version
- The folder I created
- The exact next prompt I should paste (mention I should look for "Prompt
A2 — Your First Claude Code Prompt" in the email I received from AI Built
By You)
- A "things that might go wrong later and how to fix them" troubleshooting
list specific to my setup
Format that final checklist so I can paste it into a markdown file and keep
it as my reference.
GROUND RULES FOR HOW YOU WORK WITH ME:
- Never assume I know what something is. If you use a word like "terminal"
or "shell" or "environment variable," briefly define it the first time.
- Never bundle steps. One step at a time, wait for me to confirm.
- Never skip the "verify it worked" check between steps.
- If I tell you something failed, ask me for the exact error message
(copy-paste it) before guessing what's wrong.
- I will not get embarrassed if I have to ask the same question twice.
Treat me like a smart friend who's just never done this part before.
Start with Step 0. Ask me the three questions.
Prompt 2
Your first Claude Code prompt.
Where: Paste into Claude Code (terminal) or Claude Desktop after Prompt 1 is done.
You'll get: A scaffolded project with CLAUDE.md, git, and a "hello world" app running locally.
Once you're installed, this prompt initializes your real project. It picks
a stack appropriate to your idea, scaffolds the structure, sets up project
memory (CLAUDE.md), and verifies the app runs.
I'm a non-technical builder. This is my very first project using you (Claude).
I've just installed Claude Code or Claude Desktop and I'm in a fresh, empty
project folder. I want you to walk me through scaffolding my first real
project — production-quality from day one, but small enough to actually finish.
DETECT MY ENVIRONMENT FIRST
Before anything else, figure out:
- Are you running as Claude Code CLI in my terminal, or as Claude Desktop?
(Check whether you have shell access via the Bash tool.)
- What's my current working directory?
- Is this folder empty, or are there already files here?
- Is git initialized? (Look for a .git folder.)
- What OS am I on? (Check via `uname` or equivalent.)
Tell me what you found in 3–5 short bullets. Then continue.
ASK ME ABOUT THE PROJECT
Before you write a single file, ask me:
1. What's the project called? (Give me a short, real name — not "MyApp".
If I'm stuck, ask me one or two questions about what it does and suggest
three name options.)
2. What does this project do, in one sentence? (Plain English. As if you're
telling a friend.)
3. Who is it for? (One sentence — the person who'll use it, not "everyone.")
4. What does success look like for v1? (One concrete sentence — e.g.,
"a visitor can submit their email and I receive it" — not "a complete
CRM platform.")
5. Any stack preferences, or should I pick? (If I'm not sure, you pick and
explain why.)
Wait for my answers. Then summarize my project back to me in your own words
and ask: "Is that right?" Only proceed after I confirm.
PICK THE STACK (IF I HAVEN'T SAID)
If I left it to you, pick a stack appropriate to the project shape. My defaults
for a first-time builder:
- Static content site → Astro
- Web app with auth, database, real interactivity → Ruby on Rails 8
- JavaScript / React leaning → Next.js (App Router)
- Pure backend / automation / script → Python with FastAPI or a plain script
- Internal tool with a UI → Rails or Next.js
Briefly tell me what you picked and why (one paragraph — talk like a senior
engineer giving me the lay of the land, not like a tutorial).
SCAFFOLD THE PROJECT
Now do the actual work. For my chosen stack:
- Run the right "create new project" command (e.g., `rails new`, `npx
create-next-app`, `npm create astro@latest`).
- Wait for it to finish, show me the output.
- Verify the install worked by listing the top-level files.
CREATE THE CRITICAL PROJECT DOCS
1. CLAUDE.md — this is the file that gives every future Claude session
context about my project. Include:
- Project name + one-line description
- Who it's for
- The v1 success criterion I gave you
- Stack and key versions (Ruby 3.3.x, Rails 8.1.x, etc.)
- How to run the app locally (the exact commands)
- How to run the tests
- Anything weird about how I want this built (style preferences,
naming, anything I mentioned earlier)
- A "Things future Claude should know" section — leave it stubbed for
me to fill in as I learn
2. README.md — what this is, how to install dependencies, how to run it.
Written so I (or a future me) can pick this up after a month off.
3. .gitignore — appropriate to my stack. Don't generate a generic one — be
specific to what I chose.
4. .env.example — even if I don't have secrets yet, scaffold the pattern.
Show what real secrets would go here (DATABASE_URL, API keys, etc.) and
remind me .env itself must NEVER be committed to git.
INSTALL & RUN LOCALLY
- Install dependencies (bundle install / npm install / pip install -r
requirements.txt — whichever applies).
- Set up the database if my stack needs one (rails db:create db:migrate;
create the Postgres DB if needed).
- Start the dev server.
- Tell me the local URL to open in my browser (usually
http://localhost:3000 or http://localhost:5173) and what I should see
when it loads.
- WAIT for me to confirm I see it working before continuing.
INITIAL GIT COMMIT
Once the app runs, make my first real git commit:
- git add .
- git commit with a clean first message like
"[Chore] Initial scaffold for <project name>"
- DO NOT push anywhere yet. I'll set up GitHub when I'm ready.
EXPLAIN WHAT JUST HAPPENED
At the very end, write me a "What we just built" summary, in plain English,
covering:
- The folder structure (top-level folders only) and what each one does
- The 3–5 most important files I should know about, and what each one does
- What I have running locally and how to start/stop it next time
- What the next milestone is (the smallest possible v1 feature I should
build next — something I'll tackle in Prompt A3)
- The single command I'll use most often during development
Use plain language. No buzzwords. If you have to use a technical term, define
it in parentheses the first time.
GROUND RULES
- Stop and ask me to confirm before any irreversible step.
- If something fails, copy the EXACT error and explain it before guessing
a fix.
- Production-quality from day one — that means tests-friendly structure,
secrets in env vars not code, a .gitignore that actually works, and a
README the next person could follow.
- Don't add features I didn't ask for. Scaffold + one real "hello world"
page or endpoint that proves the stack works. Nothing more.
Start by detecting my environment and then asking the project questions.
Prompt 3
Deploy your first feature.
Where: Paste into Claude Code or Claude Desktop, in your project folder.
You'll get: A real, deployed feature anyone with the URL can visit.
This is the loop you'll use forever. Pick one feature, describe it in plain
English, build it, test it, deploy it. The moment your software stops being
a "maybe someday" and becomes real.
I'm a non-technical builder. I've already scaffolded my project using you
(it should have a CLAUDE.md in this folder — read it first to refresh your
context on what we're building, who it's for, and what success looks like).
Today I want to ship my first real feature. End-to-end. From a blank function
to something visible on the internet at a real URL someone else could open.
This is also a teaching moment for me. I want to learn the exact loop you
walk me through today, because it's the loop I'll use forever.
READ CLAUDE.md FIRST
Before anything, open and read CLAUDE.md in this folder. Summarize back to
me in 3 bullets: what this project is, who it's for, what v1 success looks
like. If CLAUDE.md is missing or thin, ask me to fill in the gaps.
STEP 1 — PICK THE FEATURE
Ask me: "What's the smallest possible feature that would make this project
real? Describe it in plain English in one or two sentences."
If my answer is too big (anything that would take more than a few hours to
ship), push back. Suggest 2–3 smaller versions of the same idea and ask me
to pick one. Examples of "too big": "user accounts with email verification
and password reset." Examples of "right-sized": "a contact form that emails
me when someone fills it out." Smaller is better. We're building muscle, not
features.
Once we agree, write the feature down in one sentence as the title of a tiny
spec we'll work from. Show it to me. Confirm.
STEP 2 — DESIGN IT
Write a tiny spec — five short sections, half a page total:
1. What the user sees (the UI / page / endpoint).
2. What the user does (the action — clicks, types, submits).
3. What the system does in response (the behavior — save to DB, send
email, return JSON).
4. What success looks like (how I'll know it worked — a green checkmark, a
confirmation page, a row in the database).
5. What's explicitly NOT in scope this round (so we don't scope-creep).
Show me the spec. Ask: "Is this what you want?" Only proceed after I confirm.
STEP 3 — BUILD IT
Implement the feature. As you work:
- Tell me in plain English what you're about to do before each significant
change.
- Show me the files you're creating or editing.
- Keep edits small and reviewable — no 500-line drops without a heads up.
- Use the conventions of my stack (Rails generators if Rails, App Router
file conventions if Next.js, etc.).
- Add a basic test where it's natural — at minimum, a smoke test that
proves the happy path works.
When the feature is done in the code, tell me explicitly: "Done writing.
Ready to test locally."
STEP 4 — TEST IT LOCALLY
- Start the dev server (or have me do it).
- Walk me through testing the feature end-to-end in my browser. Be
specific: "Open http://localhost:3000/contact, fill in the form with
test data, click Submit. You should see a green confirmation banner."
- WAIT for me to confirm it works locally.
- If it doesn't work, debug with me. Ask for the exact error message or
behavior. Don't guess.
STEP 5 — COMMIT
Once it works locally:
- git status (show me what changed)
- git add the relevant files (NOT a blanket git add . — name the files)
- git commit with a clean message: "[Feature] <one-line description>"
- Show me the commit summary.
STEP 6 — DEPLOY TO A FREE PREVIEW URL
Pick the right free host for my stack and walk me through deploying:
- Astro / static site → Vercel or Netlify or GitHub Pages
- Next.js → Vercel (it's the natural home)
- Rails → Render or Fly.io (both have free tiers good enough for previews;
Fly is faster, Render is simpler — recommend ONE based on my comfort)
- Python (FastAPI, Flask) → Render or Fly.io
- Node backend → Render or Fly.io
For my chosen host:
- Have me create an account if I don't already.
- Connect my GitHub repo (we'll set up GitHub first if needed — push my
local repo to a new private repo on github.com).
- Configure the host: build command, start command, env vars, database
if needed.
- Deploy.
- Wait for the build to complete.
- Give me the live URL.
- Have me open it and confirm my feature works on the deployed version.
STEP 7 — DOCUMENT WHAT CHANGED
Update CLAUDE.md with:
- The feature I just shipped (one line under a "Shipped Features" section)
- The live URL
- Any new env vars or external services I now depend on
- Anything weird I learned while building this that future Claude should
know
Update README with deploy instructions if they're not there yet.
Make a final commit: "[Docs] Update CLAUDE.md after shipping <feature name>."
STEP 8 — THE LOOP
Now teach me the loop I just ran, so I can run it myself next time. Output
this as a clean numbered list I can save:
1. Pick the smallest possible next feature.
2. Write the tiny spec (5 sections).
3. Build it (in small, narrated chunks).
4. Test locally end-to-end.
5. Commit with a clear message.
6. Deploy to the live URL.
7. Update CLAUDE.md.
End with: "What's the next feature?" and let me decide.
GROUND RULES
- Production-quality. Don't take shortcuts that we'll regret in a month.
- Real test for the happy path. Doesn't have to be elaborate. Has to exist.
- Never push to main / production without me confirming the local test
passed.
- Never commit secrets or .env files.
- If we hit a wall — really stuck, not just slow — say so plainly and tell
me what we'd need to make progress. I'd rather pause and think than push
through with the wrong approach.
Start by reading CLAUDE.md and summarizing it back to me.