a brady ux course
not a dictionary — a phrasebook: the words you'll hear (and say) while you talk a real thing into existence with AI. every entry in plain language, most with the exact sentence you'd actually say. 120 words, 15 magic sentences, zero jargon left unexplained.
the course invents a few words of its own. here's what they mean — consider this your decoder ring.
the one-page summary of your idea, written by the guide from your own words in module 0. it's the seed every other doc grows from — and it's living: change your mind, it updates.
say it like this“update my brief — it's just for plant people now, not all pet people.”
everything you know about your idea — the problem, the dream, the worries — organized into one doc after your three talks in module 1. proof you knew more than you thought.
say it like this“read the discovery doc and tell me what's still fuzzy about the idea.”
the plan. one page: the problem in one story, who it's for, version one, the later list, and — the hero section — what it is NOT. the boss of the build; the ai reads it before every work session.
say it like this“read the intent doc in this folder before we do anything — that's the plan.”
your intent doc chopped into steps, each one sized to be exactly one prompt. it's a map, not a prompt — you send one item at a time, top to bottom, looking after each.
say it like this“next task: [paste item 1 from your build list] — tell me what to look at when it's done.”
the module 4 fix list, generated from your own confused-stranger walkthrough — every hesitation turned into one prompt-sized fix. checking things off is the best feeling in software.
say it like this“next fix from my checklist: the empty screen should say what goes there.”
the line between version one and everything else. the test for every feature: does version one still prove the idea without it? if yes — below the line it goes.
say it like this“is this feature above the cut-line, or can version 2 have it? be ruthless with me.”
where cut features get parked instead of deleted. nothing dies — it's not gone, it's parked. version 2 is allowed to exist; version 1 has to exist first.
say it like this“park dark mode on the later list — version one doesn't need it.”
the smallest version of your idea you'd still be proud to show ONE person. pros call it an MVP — minimum viable product — which is the same thing wearing a lanyard.
say it like this“for version one: one plant, one reminder. that's the whole list.”
brady's core move: something goes wrong or an idea shows up, and you just talk at the machine until you're empty. rambling, contradictions, 'wait actually' — all of it. the ai sorts the mess, and the mess is the good part.
say it like this“incoming thought-dump — don't build anything yet, just organize what i say and tell me what you heard.”
the first message of every project. it says: here's what we're building, here's the plan file — read it. keep things organized. stay consistent. and the magic sentence: if i contradict the plan later, push back before you build.
say it like this“before we start — read the plan file, and if i ever ask for something that contradicts it, have my back and push back first.”
the rhythm of building. big asks drift — 'build the whole app' gets you a confused mess. small asks land. one task, look at the result, next task. this rule is doing so much work it should get paid.
say it like this“build the screen where a user uploads one photo. just that — we'll do the rest one step at a time.”
when the ai quietly changes things you didn't ask about — colors shift on their own, a button you never asked for appears, something that was there yesterday is gone. you'll spot it instantly, because you're the one who knows what it should be.
say it like this“the header changed color on its own — that's drift. put it back exactly how it was.”
the escape hatch when a project feels too messy to save: start a fresh folder, bring the plan and the good parts over, leave the mess behind. it feels like cheating. it's allowed.
say it like this“this got messy. let's duplicate-and-clean: new folder, bring the plan and the working screens, leave the rest.”
open your app, pretend you've never seen it, and use it while narrating out loud like a confused stranger — 'ok what is this. what do i tap. why did that happen.' every hesitation is data. confusion is the fix list writing itself.
say it like this“i did my walkthrough — here's every spot i went 'wait, what?': ...”
typing exactly what you'd say, as you think it — typos kept, 'idk' kept, mind changed mid-sentence and no backspace. the opposite of school writing. polished sentences hide the maybes; the ai wants the maybes.
say it like this“ok so my idea is like an app for plant people wait no not JUST plants its more like...”
the thing you build in this course. it's real, live, and yours — but the point isn't a perfect product; the point is finishing knowing how to build anything. the app is the homework. the skill is the prize.
say it like this“this is my training build — i'd rather learn the loop than gold-plate version one.”
this tab. the course keeps your docs and your build list so you never need a notepad; the building happens over in claude code. come back, glance, grab the next item, head over — that's the loop.
say it like this“back at home base — grabbing the next item off my build list.”
the ✋ button — help that's always there, mid-lesson, mid-anything. the guide knows your project, your plan, and where you are, and answers in plain language. no forum, no ticket queue.
say it like this“✋ quick one — what did you mean by 'artifact' back there?”
a plan that stays true because you update it when you change your mind — plan first, then build. ten seconds of 'update the plan' keeps you and the ai looking at the same truth, and makes every future prompt smarter.
say it like this“hey, update the plan: we're doing reminders by text now, not push notifications.”
the graduation move: drop ALL your docs into the project folder — brief, discovery doc, notes, everything — then tell the ai exactly one file is in charge. more context makes it smarter, as long as one file is the boss.
say it like this“i put all my docs in the folder. the intent doc is the boss — everything else is background.”
the physical world of the build: files, folders, and the couple of places work actually happens.
one saved thing on your computer — a doc, an image, a page of code. your whole app is just files in a folder. and the course's deepest rule: the project lives in files, not in anyone's memory. files survive. memory doesn't.
say it like this“which file does the homepage live in?”
a home for files. one project, one folder — claude code works inside whichever folder you point it at, and whatever's in there is what it can see. (fancy people say 'directory.' same thing.)
say it like this“make a new folder called my-plant-app and put everything for this project in there.”
THE folder for your build: your plan file plus everything the ai creates. every session starts by pointing claude code at it — the desktop app's folder picker, just above the input bar.
say it like this“new session: point claude code at the project folder, say hi, grab the next task.”
the screen behind all your windows — which is secretly also just a folder. the easiest place to keep your project folder is right there where you can see it.
say it like this“put the project folder on the desktop so i can always find it.”
short for application: any program you open and use. your browser is one, claude code is one — and the thing you're building is about to be one.
say it like this“is this a mac app or does it live in the browser?”
the plain text window where you type commands straight to your computer. mac: cmd+space, type 'terminal'. it looks like hacker stuff; it's just typing. optional in this course — the desktop app is the easy way.
say it like this“i opened the terminal and typed the install command — here's what it said back: ...”
windows' version of the terminal. windows key, type 'powershell'. same idea, different name, slightly bluer.
say it like this“i'm on windows — do i put this in powershell?”
one instruction typed into a terminal. press enter and the computer does it. in this course you'll paste maybe two, ever — and both come pre-written.
say it like this“what does this command actually do, in plain words, before i run it?”
putting a new program onto your computer so it can run. claude code installs like anything else: download, open, sign in. that's the most 'technical' thing in this whole course.
say it like this“i installed the app and signed in — what's next?”
copy grabs text onto an invisible clipboard (cmd+c / ctrl+c), paste drops it wherever you are (cmd+v / ctrl+v). half this course is: copy here, walk over there, paste. it's a legitimate professional workflow.
say it like this“copy the whole error — don't read it, just copy it — and paste it to claude code.”
the invisible pocket that holds the last thing you copied. it holds exactly ONE thing — copy something new and the old thing is gone. that's why the course re-offers important prompts right where you need them.
say it like this“wait, i copied something else since — where do i get that prompt again?”
download: a file travels from the internet to your computer (it lands in your downloads folder). upload: the same trip, reversed.
say it like this“i downloaded my intent doc — now i drag it into the project folder, right?”
a bunch of files squished into one file so they travel easy. double-click to unzip and get them back out. if someone hands you a .zip, it's a box, not a bomb.
say it like this“it gave me a zip — do i unzip it before dragging it in?”
a photo of your screen. mac: cmd+shift+4 and drag. windows: win+shift+s. the fastest way to show the ai — or a friend, or the course — exactly what you're seeing.
say it like this“here's a screenshot of what it looks like right now — the button's floating in the wrong corner.”
the app you look at the internet with — chrome, safari, edge. your app will live its whole life in one: first at a localhost address only you can see, then at a real URL.
say it like this“open it in the browser and tell me what address to type.”
one page inside your browser window. the course is one tab — home base — and your app will open in another. leaving a tab doesn't close it; it's right there when you come back.
say it like this“keep this tab open, do the build over there, come back when you're done.”
the internet address of a page — the text in the bar at the top of the browser. your graduation prize is one of these: a real URL you can text to a real person.
say it like this“give me the URL to open so i can see it running.”
a URL you can click. the free kind your hosting hands you works great; a domain name is the same thing with a nicer outfit.
say it like this“send the live link to one person. today. i'll wait.”
one sitting of work with claude code. each new session starts fresh — which is fine, because your plan lives in a file, and the first move of every session is having the ai read it.
say it like this“new session — start by reading the intent doc in this folder, then tell me where we left off.”
the tail on a filename — .html, .png, .md — that says what kind of file it is. .md is 'markdown': plain text with simple formatting, and it's what your project docs are. any text app can open one.
say it like this“it saved as intent.md — that's the plan file, the .md just means plain text.”
the way computers like names: my-plant-app. no spaces, no capitals. spaces in names confuse tools sometimes; dashes never confuse anything.
say it like this“name the folder fern-sitter — lowercase, dash, no spaces.”
the words that come up when you and the builder are actually working together.
the thing you're learning to talk to. the only fact about it that matters here: it can build almost anything you can describe — and the better you describe, the better it builds.
say it like this“here's my idea — ask me everything you need to know before we start.”
the ai that lives on your computer and actually does the work — writes the files, runs the app, fixes what breaks. you talk, it types. in this course, it's your builder.
say it like this“hi, what can you do?”
one message to the ai. that's the whole word — not magic, not code, just a message. the skill of this entire course is making one prompt carry one clear ask.
say it like this“one prompt, one task: add a save button to the photo screen.”
what building actually is. you're not submitting tickets to a vending machine — you're working with something that knows the whole project. ask it things between tasks. react. think out loud at it. people who chat build better than people who command.
say it like this“before the next task — what would YOU do differently about this screen?”
everything the ai can currently see: your messages, your files, your plan. more context makes it smarter — as long as exactly one file is in charge. when it acts confused, it's usually missing context, not intelligence.
say it like this“for context: read the intent doc first, then look at the photo screen before you answer.”
your spoken words, written down. hand transcripts to the ai raw — don't summarize first. summarizing throws away the maybes, and the maybes are the good stuff.
say it like this“here's the raw transcript of my call with my sister — pull out everything that matters for the app.”
turning speech into text. your phone does it, your computer does it. it doesn't need to be pretty — the words just need to land somewhere the ai can read them.
say it like this“i'm going to ramble into my phone and paste you the transcription — sort it out for me.”
claude code asking 'can i create this file? can i run this command?' before doing it. a safety feature, not a warning. brady's rule: connect it to what you just asked for — you asked for a screen, it wants to make files? that's just the work. surprised by one? make it explain first.
say it like this“before i approve this — explain in plain language what it does, why you need it, and what happens if i say no.”
how it avoids guessing wrong about YOUR product. answer honestly, in plain words. don't perform expertise you don't have — 'i don't know, you decide' is a fully legit answer, and it's in the phrasebook twice because it matters.
say it like this“honestly? i don't know — you decide, and tell me what you picked.”
to start a program so it's actually going. your app only exists on screen while something is running it — it's not gone between sessions, just asleep. and claude code will happily run it; it just doesn't always volunteer. you ask.
say it like this“run the app and give me the address to open in my browser. keep it running, and tell me when it's ready.”
the scary red text when something breaks. it is written in ai, not in human — so don't read it. copy the WHOLE thing, paste it, and say what you expected to happen instead. let the ai read its own mail.
say it like this“i got this error: [paste the whole scary thing]. i expected the photo to upload. what happened?”
a mistake in the software — something that doesn't work the way it should. professionals make them hourly. finding one doesn't mean you did it wrong; it means you're building software.
say it like this“found a bug: tapping save twice makes two plants. it should just save once.”
hunting a bug down and fixing it. your half of debugging is describing what's wrong and what you expected; the ai's half is everything else. that's the fair trade.
say it like this“let's debug: it worked yesterday, i changed nothing, now the reminder never comes.”
the reset button for confusion. lost track? ai seems lost too? ask for a report of what's built, what works, what's half-done — now you're both looking at the same truth again. brady does this constantly.
say it like this“give me a plain-language report of the current state of the project: what's built, what works, what's half-done.”
the written instructions software is made of. in this course, the ai writes every line of it. you never need to read code — you need to look at the thing it makes, the way an owner would.
say it like this“don't show me the code — show me the result, and tell me in plain words what changed.”
claude's free plan is fine for your first sessions; the paid plan (~$20/mo) is the smooth ride for the two build weeks. one or two months is plenty — cancel after if you like. never pay for anything without knowing exactly why.
say it like this“i'm hitting limits on the free plan — is now the moment the paid month is worth it?”
the ai plan saying 'that's enough for now.' nothing broke and you didn't do anything wrong — wait a bit or upgrade, and it resets. building in short sittings barely ever hits one.
say it like this“i hit a limit mid-task — when it resets, remind me where we were.”
what you hired the ai to do in your alignment prompt: if you ask for something later that contradicts your own plan, it speaks up before building. your own personal guardrail, working for free.
say it like this“if this contradicts the intent doc — have my back. push back before you build it.”
the specific ai brain answering you — claude is one, and it comes in versions, like anything. if claude code mentions a model name, that's all it means. newer generally = better builder.
say it like this“which model am i talking to right now? use the best one for building.”
a complete, professional answer to any question the ai asks that you don't care about or don't understand. deciding is its job when you don't have an opinion. don't perform expertise — spend yours where you have it: on what the thing should BE.
say it like this“idk — you decide. just tell me what you picked so i can veto it if it's weird.”
the words the ai will say back to you. you never have to use them — but knowing them turns 'huh?' into 'oh, that.'
one page on the internet — or the file that makes it. a website is a stack of these with a front door.
say it like this“make the about page a simple webpage: who it's for, why it exists, one photo.”
a website you mostly read; a web app you mostly DO things in. if people sign in, save stuff, or tap buttons that remember, it's an app. yours is probably an app that lives on the web — the sweet spot for building by talking.
say it like this“is this a website or a web app? it needs to remember each person's plants, so... app?”
the front door — the first page people see. a 'landing page' is a homepage with exactly one job: explain the thing, offer one action. resist the urge to say everything on it.
say it like this“the homepage should do one thing: explain the app in one sentence and show the button to start.”
one view of your app — whatever's in front of you at a given moment. describe your app screen by screen and the ai will build it screen by screen. (also called a page or a view. same thing.)
say it like this“build the screen where someone adds their first plant. just that screen.”
the thing users press to make something happen. every button should say what it does — 'save' is fine, a verb from your app's world is better. (marketers call the big important one a CTA — call to action.)
say it like this“rename the button from 'submit' to 'water it' — say what actually happens.”
the words on or near a thing that say what it is — button text, field names, icon captions. small words doing huge work. if your grandmother would squint at it, it needs a better label.
say it like this“every field needs a label — no mystery boxes.”
a form collects info; each blank inside it is a field. the email box is a field; the whole signup is a form. fewer fields, more finishers — every field you cut is a favor to your users.
say it like this“the signup form is three fields. can we make it one?”
a little window that appears on top of everything and wants an answer before you can continue. (also called a popup or dialog.) use sparingly — every modal interrupts somebody's day.
say it like this“don't make delete a modal party — one 'are you sure?' is plenty.”
temporary stand-in content — the gray 'your email' hint inside an empty field, or fake text and images holding a spot for real ones. if the ai says it 'added placeholder content,' the layout is real but the words are still your homework.
say it like this“replace the placeholder text on the homepage with the real pitch from my intent doc.”
what a screen shows before there's anything on it — day one, zero plants. the moment to tell people what goes there and how to start. a blank screen is a shrug; an empty state is a welcome.
say it like this“give the plant list an empty state: 'no plants yet — add your first one' with the button right there.”
what users see while the app is working — usually the spinning circle. a good one says what's happening ('finding your plant...'); a missing one just looks broken.
say it like this“the photo upload needs a loading state — right now it looks frozen for three seconds.”
a tiny picture that means a thing — the gear (settings), the trash can (delete), the hamburger (the three stacked lines that mean 'menu'). icons plus labels beat icons alone; not everyone speaks fluent gear.
say it like this“add a label next to the gear icon — not everyone knows it means settings.”
the tiny icon in the browser tab. cosmetically minor, disproportionately satisfying. one prompt and your app has a face.
say it like this“make a favicon from the app's logo so the tab looks real.”
the shape of the letters. changing it changes the whole mood of the app — worth exactly one prompt of experimenting, and text should never be smaller than comfortable.
say it like this“the font feels corporate — try something warmer, and bump the size up one notch.”
where everything sits on the screen and how it's arranged. 'the layout broke' means things are in the wrong places, not gone — usually one prompt to fix.
say it like this“on my phone the layout breaks — the buttons stack on top of each other.”
how strongly text stands out from what's behind it. light gray on white is a crime. if you're squinting, so is everyone — and someone's grandmother simply can't read it at all.
say it like this“check the whole app for contrast — anything whispering, make it speak up.”
making the thing work for every human: text big enough to read, colors that don't whisper, buttons that say what they do, everything reachable by keyboard. it has a fancy name, but it's really just craft — and you don't need to know the rules, you need to care and then ask.
say it like this“make this accessible — contrast, keyboard, labels, text size. tell me what you changed.”
a layout that reshapes itself to fit the screen it's on — big monitor, laptop, phone. most people will meet your app on a phone, so 'looks great on mobile' isn't polish, it's table stakes.
say it like this“make it responsive — and show me what it looks like at phone size first.”
the same app in night colors. loved by many, needed by none on day one — a classic later-list item.
say it like this“dark mode goes on the later list. version one ships in daylight.”
frontend: everything users see and touch. backend: the machinery behind it — where data gets saved, rules get enforced, secrets get kept. you never need to know which is which... but 'is this frontend or backend?' is a great question to just ask.
say it like this“is the reminder logic frontend or backend? explain like i'm the owner, because i am.”
a computer whose whole job is serving your app to whoever asks. during the build, your own computer plays server, privately — that's localhost. deploying is handing the job to a real one that never sleeps.
say it like this“when i close my laptop the app disappears — right, because MY laptop is the server. time to deploy.”
where your app remembers things — accounts, saved plants, watering history. screens can be rebuilt anytime; the database is the part that would actually hurt to lose. treat it with respect.
say it like this“before we change anything about the database — what's in it, and is it backed up?”
how one piece of software talks to another. your app asking a weather service for today's forecast? that conversation happens over an API. you'll hear this word constantly; it's always just 'the phone line between two programs.'
say it like this“is there an API that identifies plants from a photo? if yes, can we use it?”
a password that lets YOUR app use someone else's service. anything called a key, secret, or credential must never ship where the public can see it — this is the one mistake that's genuinely worth being careful about, and one sentence prevents it.
say it like this“is anything in this project secret — keys, passwords? make sure none of that ships.”
short for authentication: everything about accounts, passwords, and signing in. 'add auth' means 'let people have accounts.' it's also famously fiddly — a strong candidate for version 2 unless your idea truly needs it on day one.
say it like this“does version one need auth, or can it work for one person with no login?”
the three languages of every webpage. HTML is the stuff (the words, the boxes). CSS is the look (colors, sizes, where things sit). JavaScript is the behavior (what happens when you tap). you'll write none of them — but when the ai says 'that's a CSS issue,' now you know it means the look.
say it like this“you said it's a CSS problem — so the button works, it just looks wrong?”
pre-built code the ai stands on so it isn't reinventing wheels. if it says 'i used react' or 'i added a library,' that's a builder choosing good materials — nod and check the result like you would anything else.
say it like this“you picked a framework — fine by me. does it change anything about how we deploy?”
a reusable piece of the interface — THE button style, THE plant card. built once, used everywhere, so changing the component updates every copy of it. it's why good apps feel consistent.
say it like this“make the plant card a component so every screen shows plants the same way.”
one thing your app can do. ideas love collecting these; version one is a SHORT list of them, and the cut-line is where you tell the rest 'later.'
say it like this“that's a lovely feature. later list. what's the next build-list item?”
a numbered snapshot of your thing as it grows — version 1, version 2. saying a number out loud is a commitment device: version 1 has to exist before version 2 is allowed to.
say it like this“that's version 2 talking. version 1 first.”
keeping the same info matched everywhere it appears — your phone and your laptop showing the same plant list. if they disagree, something isn't synced.
say it like this“if i add a plant on my phone, does it sync — will my laptop show it too?”
a spare copy, in case the original dies. the course rule 'files survive, memory doesn't' has a big sister: files survive best when there are two of them in different places.
say it like this“how do i back up the project folder — and the database, if there is one?”
the browser keeping saved copies of things so pages load fast. helpful — except it sometimes shows you the OLD version of your app after a change. when 'nothing changed,' suspect the cache first.
say it like this“i made the change but the page looks the same — cache? do i hard refresh?”
reload, but ignore the saved copy: cmd+shift+r on mac, ctrl+shift+r on windows. the first thing to try whenever your change 'didn't work' — half the time, it worked fine and the browser was showing you yesterday.
say it like this“before we debug anything — i'll hard refresh and check it's not just the cache.”
asking the browser to load the page fresh — the circle-arrow button, or cmd+r / ctrl+r. the polite version of turning it off and on again.
say it like this“save, refresh, look. that's the loop.”
the browser's behind-the-scenes notes page, where errors get written down even when the screen looks fine. if the ai asks 'what does the console say': right-click the page → inspect → console tab → copy the red stuff.
say it like this“the console says something in red — pasting it now: ...”
notes software writes about what it's doing, line by line, timestamps and all. when something misbehaves, logs are the security-camera footage — you don't watch it; you hand it to the ai.
say it like this“check the logs and tell me what actually happened when she tapped save.”
the internet's 'that page doesn't exist.' usually a link pointing somewhere that isn't there — one of the most fixable problems in software. (the number is just an old code that stuck.)
say it like this“the about link gives a 404 — it's pointing at a page that doesn't exist yet.”
when a program stops completely. dramatic-looking, completely normal, never permanent. copy whatever it said on the way down, paste it, keep going.
say it like this“it crashed when i uploaded a huge photo — here's everything it said: ...”
your own computer serving your app to you, privately — the address looks like localhost:3000. only you can see it, which makes it the correct first audience. live comes later; localhost is where the honest work happens.
say it like this“it's running at localhost:3000 — i'm looking at my own app on my own machine. wild.”
the :3000 part of localhost:3000 — a numbered door on your computer that the app is served through. different programs use different doors so they don't collide. if the ai says 'port 3000 is busy,' something else is standing in the doorway — tell it to use another.
say it like this“port 3000 is busy? use a different port and give me the new address.”
the shipping words. shorter list than you'd think — going live is the easy part.
the whole scary word, in one paragraph: your app is a folder of files. deploying means copying that folder to a computer that's always on, so the internet can see it. that's it. that's the entire mystery.
say it like this“we're ready to deploy — what's the drag-a-folder way to get this live?”
on the internet, reachable by anyone with the link. localhost is the rehearsal; live is the show. the distance between them is one deploy — about a minute.
say it like this“it's live. i have a URL. i can text it to a human being.”
a spot on an always-on computer where your app lives. the kind this course uses is free and the drag-a-folder kind — hosting is a place, deploying is the trip there.
say it like this“which free hosting should this project use? the drag-a-folder kind, please.”
the way brady's shipped for years: services where you literally drag your project folder onto the web page and it hands back a live link. it takes about a minute. really.
say it like this“export what needs to ship into one folder i can drag onto the hosting page.”
a real name — yourthing.com — instead of the random free link. the one thing on the internet that actually costs money: about the price of a pizza, per year. completely optional; the free link is honestly fine for version one.
say it like this“is myplantapp.com available, and how do i point it at my hosting?”
a name in front of a name: app.yourthing.com. free once you own the domain — one pizza, many doors.
say it like this“put the app itself at app.myplantapp.com and keep the homepage at the main address.”
the S means the connection between your app and its visitors is scrambled and safe. modern hosting sets it up automatically — if the browser shows a padlock next to your URL, you're good. (SSL is the older name for the same idea.)
say it like this“does the live site have https? check that the padlock shows up.”
the moment you tell people it exists. shipping is technical; launching is social — and it's the step people skip because it's scarier than all the technical stuff combined. one person. today.
say it like this“the launch is a text message: 'hey. i built a thing. look.'”
when a site is temporarily unreachable. rare on good hosting, almost never your fault, and it fixes itself embarrassingly often. check once, sip coffee, check again.
say it like this“the site's down — is it my deploy, or is the hosting having a day?”
counting visits: how many people came, from where, what they touched. a later-list item — version one's analytics is texting one person the link and reading what they say back.
say it like this“analytics can wait. what did the ONE person i sent it to actually say?”
search engine optimization — making your thing findable on google. 90% of it is unglamorous: pages with real words on them that honestly answer things real people search for. version 2 territory for most training builds.
say it like this“someday: what would someone google if they had the problem my app solves?”
people showing up. traffic is the flow; users are the ones who stay and do things. day one, both are allowed to be a number you can count on one hand — that's what day one is for.
say it like this“three visitors and one of them was my mom. that's traffic. we ride at dawn.”
the pre-ship habit: before anything goes live, ask the ai to sweep for keys and passwords that shouldn't travel. thirty seconds. professionals forget it all the time; you won't, because it's one sentence.
say it like this“is anything in this project secret — keys, passwords? make sure none of that ships.”
shipping again, smaller. the loop never changes: talk it out, plan it small, build one prompt at a time, look at it, polish it, ship it. your later list is waiting — and now you know exactly how to do it.
say it like this“version 2, task one — from the later list: the cactus people have been patient.”
whole sentences worth stealing — the prompts the course teaches, collected. copy freely; they work in any AI tool, on any project, forever.
the table-flipper. starting anything — the ai pulls the info out of you, and answering is easy.
the same move, aimed anywhere: a plan, a screen, an email. it never stops being useful.
any question you don't have an opinion on. a complete, professional answer. don't perform expertise.
any permission ask that surprises you. you never need to read the technical text — you can always demand the translation.
the result is wrong or something drifted. plain, unapologetic, no tech words. the ai never gets offended and neither should you.
when it's right. saying so helps more than you'd think.
after any task, to stay the owner instead of a passenger.
any time you want to SEE your thing. your 'let me see it' button, forever.
you've lost track, or the ai seems lost too. now you're both looking at the same truth.
the build loop itself. one item, one prompt, one little demo at the end of each.
stuck between directions. the thought-dump, aimed at a decision.
the module 4 quality pass. you don't need to know the rules — you need to care, and then ask.
right before every deploy. thirty seconds, saves headaches.
every time you change your mind. the plan stays the boss only if it stays true.
the graduation move: all your docs in the folder, exactly one file in charge.
this page is the vocabulary. the course is the fluency: a guide walks you from "i have an idea" to a real app, live on the internet — every lesson tailored to your project, every one of these words hyperlinked right where it's spoken. no code, no experience.
join the list — founding price