a brady ux course
build your idea by talking.
a self-paced course where an AI guide walks you from "i have an idea" to a real app, live on the internet — and the whole course rebuilds itself around your idea. no code. no experience. you just have to be able to describe what you want.
the first 20 seats. after that it's $299 — and the price only ever climbs, never drops. checkout by stripe; your access code lands in your inbox the moment you pay.
no spam — occasional build-in-public notes, and a heads-up before the price climbs.
how it works
six modules, at your pace. the first thing you do is tell the course your idea — out loud — and from that moment, every lesson, example, and prompt is about the thing you're actually building.
tell it your idea
the guide interviews you. you talk. messy is good — it turns your rambling into a real project brief. napkin sketches and notes-app graveyards welcome — the pile gets put to work.
argue it into a plan
the AI drafts your plan; you push back out loud until version one is small enough to actually happen.
build it, one prompt at a time
with claude code and your personal build list — every step sized to be one message. then polish it until you'd put your name on it.
ship it
your thing, at a real URL, texted to a real person. "you talked this into existence."
🔒 that's the shape of it — the full method, with every step spelled out and every prompt written for your project, is the course. founding seats are open — $149 for the first 20.
what it actually looks like
these aren't brochure mockups — they're real moments from the course UI, shown with the demo project (fernsitter, a plant-watering app for a forgetful sister). the amber parts are the tailoring: the moment you tell the course your idea, every one of them rebuilds around it.
every lesson knows your project — the amber parts regenerate for your idea.
✓ use itstart over
you talk, it listens — messy is good, and it always checks before using your words.
why: the ai builds best when exactly one file is in charge — and now you know that too.
every message you'll ever send: pre-written for your project, copy-ready, with the why.
✋ raise your hand anytime — the guide knows your project and edits your docs live.
the whole thing, in thirty-four seconds
idea → plan → build → live.
one course, six very different apps
your build won't look like anyone else's — it's your idea, your people, your whole look. fernsitter is the course's real demo build; the other five show the range of thing a version one can be. flip through: each one started as a sentence somebody could have said out loud.
"AI makes building easy now. why would i pay to learn it?"
because the tool was never the hard part. AI really can build an app in a minute — and the internet is littered with half-built ones. starting has never been easier. finishing hasn't changed at all.
what's rare isn't getting AI to write code. it's knowing what to build. keeping it small enough to actually ship. noticing when the machine quietly does the wrong thing. taking a real thing to a real URL and showing it to a real person.
those are judgment skills — and they don't get easier as the tools improve. they get more valuable. that's what this course builds, on your own idea, until you've finished once. after that, you won't need us. that's the point.
what makes it different
it's about YOUR idea
no todo-app tutorials. your brief, your plan, your build list, your prompts — all generated for your actual project, and updated when you change your mind (you just tell the guide).
voice-first
the skill isn't coding — it's describing. you'll talk to the course, and you'll talk to the AI that builds. typing works too, but we'll teach you to type like you talk.
an honest deal
what you build here is your training build — real, live, and yours, but the point is that you finish knowing how to build anything. the app is the homework. the skill is the prize.
made with its own method
this entire course — the guide, the app, the engine behind it — was built by talking to AI, using exactly the workflow it teaches. it's the proof and the product.
the app is the homework. the skills are the prize.
your training build goes live on the internet — that part's real. but these are the things you keep, and they work on every idea you'll ever have:
- describing things into existence — turning a fuzzy idea into words so clear a machine can build from them. (the same clarity works wonders on humans.)
- cutting an idea down to version one — every idea is too big at first. you'll learn where to draw the line so the thing actually ships.
- directing AI instead of hoping at it — one task at a time, checking the work, catching it when it drifts. the difference between using AI and steering it.
- judging software like an owner — walking through what got built and knowing what to protect, what to fix, and how to say it.
- shipping — taking a thing from your computer to a real URL, and the harder habit: showing it to a real person.
- the loop itself — talk it out → plan it small → build → look → polish → ship. run it once here, then run it forever.
"will i be able to follow along?"
here's the whole entry exam. if you can do these three things, you're qualified:
- open a new browser tab and switch back to this one
- copy something and paste it somewhere else
- find a file you downloaded
that's it. that's the actual bar — and you just did the first one getting here. you will touch a couple of things that look technical (a terminal, once, for about a minute), but touching isn't knowing — every time, you'll be shown exactly what to click and exactly what to paste.
beyond that, the course assumes nothing — every setup step is click-by-click, every instruction comes with its why, and it's fully self-paced with autosave (life happens; your spot survives). stuck anyway? raise your hand mid-lesson and ask — the guide knows your project. and every word that sounds like jargon is one tap from a plain-language definition.
what's included
- the guide — lessons in plain language, never a wall of jargon
- a personal set of project docs — brief, plan, build list, quality checklist — generated for your idea, yours to keep
- raise-your-hand help — ask anything, anytime, mid-lesson; answers know your project
- real prompts, copy-ready — every message you'll ever send, written for you
- click-by-click setup walkthroughs — no step assumes you know anything
- everything autosaves — leave anytime, pick up where you left off
- the phrasebook — every word you'll hear while building, in plain language. free and public — browse it now; in the course, words link to it right where they're spoken
what you'll need (the honest prep sheet)
no surprises halfway through — here's everything, with real prices. the course reminds you at exactly the right moments, but if you set these up ahead of time, future-you says thanks.
a computer with chrome or safari
mac or windows. the mic in your browser is how you'll talk to the course.
your idea's paper trail
napkin sketches, screenshots of apps you like, old notes, voice memos — if your idea has a pile, don't throw it out. the course has you gather it into one folder, and in the build module your builder literally reads it, sketches and all.
a claude account — the one real cost
claude code (the AI that builds with you) needs claude's pro plan — the free account doesn't include it. the good news: you don't need it until the build module, and one or two months is plenty — cancel after if you like.
hosting
putting your app on the internet costs nothing — we use free hosting, the drag-a-folder kind.
a domain name
want yourname.com instead of a free link? about the price of a pizza, per year. completely optional — the free link is honestly fine for version one.
realistic total: about $20–40 in AI subscription across the course, and $0 required beyond that. the course itself: $149 for the first 20 founding seats — then $299, and the price only ever climbs. early belief pays.
asked honestly, answered honestly
can i really build an app if i can't code?
yes — that's the whole premise. the AI writes every line of code; your job is describing what you want, clearly, out loud. the course teaches you exactly that, and how to check the work like a pro would. no programming knowledge, no computer science degree, no "technical background."
how technical do i need to be, really?
here's the whole entry exam: can you open a new browser tab and switch back? copy and paste? find a file you downloaded? then you're qualified — that's the actual bar. you'll touch a couple of things that look technical (a terminal, once, for about a minute), but you'll be shown exactly what to click and exactly what to paste, every single time.
what do i actually have at the end?
a real app — yours, live on the internet, at a URL you can text to a real person. plus the project docs behind it (brief, plan, build list, quality checklist), and the skill that made it: you'll know how to run the same loop on any idea, with or without this course.
how much does it cost, all in?
the course: $149 for the first 20 founding seats, then $299 — the price only ever climbs, never drops. tools: about $20–40 total, because a claude account (~$20/mo, one or two months is plenty) is the only real cost. hosting your app is free. a domain name is optional, about $12 a year.
can't i just do this myself for free?
you can — the tools are public and tutorials are everywhere. what this course sells isn't secret knowledge: it's finishing. structure, pacing, a guide who knows your project, and the judgment skills — cutting to version one, catching drift, actually shipping — that free content doesn't build. if you're self-propelled, honestly: go build. if you've been "about to start" for months, this is for you.
how long does it take?
fully self-paced — no schedule, no cohort, no live sessions, ever. think a few weeks part-time: some talking sessions early, two build weeks in the middle, a polish-and-ship pass at the end. everything autosaves, so you can leave anytime and pick up where you left off.
what tools will i use?
your browser's mic to talk to the course, and claude code — the AI that builds with you. the course sets both up with you, click by click, assuming nothing. shipping happens on free hosting, the drag-a-folder kind.
what kinds of ideas work?
web apps and websites are the sweet spot — tools, trackers, little services, the "somebody should make this" ideas. if you can describe it, you can build a version one of it. part of the course is cutting your idea down to a size that will actually ship.
what if i get stuck?
raise your hand. mid-lesson, anytime, there's a guide that knows your project — your idea, your plan, your progress — and answers in plain language. no forum, no ticket queue, no waiting.
is this a video course?
no. it's an interactive app: the guide talks you through each step, asks about your idea, and generates your docs and prompts as you go. closer to being coached than being lectured.