The idea you've been sitting on is now buildable
For years, having an idea and building it were split by a wall marked "learn to code" or "raise money and hire engineers." That wall is coming down. With Claude Code, a non-technical person can describe what they want, direct the build, and end up with a real, working app.
This cohort takes you from a fuzzy idea to a shipped app in four weeks. Not a mockup, not a no-code prototype you'll outgrow. An actual app with real functionality that a real person can use. You scope it so it's buildable, build the first working version, add the data and logic that make it useful, then deploy it and put it in front of someone.
You won't become a software engineer in four weeks. You'll become someone who can go from idea to shipped product, which for a founder is the more valuable skill. Week one shares the same foundations as our other build cohorts; after that, every session moves your app forward.
What you'll learn
Turn an idea into something you can actually build
- Scope a version one that's small enough to ship but real enough to matter
- Write a clear spec Claude can execute against, the skill that separates a working build from a frustrating one
- Set up your context and memory files so Claude builds consistently
Build the first working version
- Stand up a functioning app with Claude Code, no prior coding
- Iterate by asking: describe the change, see it happen, refine
- Troubleshoot when it breaks, and learn to read what went wrong
Add the data and logic that make it useful
- Connect data so your app remembers and responds
- Add real functionality: forms, logic, an agent step, whatever your idea needs
- Work through the common failure points together, so you're not stuck alone
Ship it to real users
- Deploy your app so someone other than you can open it
- Put it in front of a real person and gather feedback
- Leave knowing how to keep building after the cohort ends
Who teaches this
Dylan, the engineer. Founder and AI strategist, currently leading AI adoption at a billion-dollar tech company. He's built software products for over a decade and shipped tools and systems for clients and himself. He builds and leads the cohorts, and runs this one the way building actually goes: spec first, build fast, break things, fix them, ship.
Who this is for
- You have a product idea and you're tired of waiting for a technical co-founder
- You're a founder or PM who wants to prototype and ship without an engineering team
- You've tried no-code tools and hit their ceiling
- You want a real, working app at the end, not a slide about one
Not for you if you just need a marketing website (take Website in Four Weeks), or you're an experienced engineer after advanced architecture. This is a first-app cohort for non-technical builders.
Prerequisites
- A computer you can install software on
- A personal Claude account with Claude Code access and healthy usage limits
- An idea to build, even a rough one. We help you scope it in Week 1
- About 5 to 7 hours a week. An app is more work than a website, so come ready
Setup instructions and an install office-hours session run before Week 1. No coding required, but curiosity and persistence help.
What's included
- Live weeknight build sessions
- Replays and lifetime access
- A starter repo and spec templates to get moving fast
- A build checklist and written guides with screenshots
- Async debugging support between sessions when you're stuck
- A cohort of builders shipping alongside you
- A demo-day recording of your app you can share
- Certificate of completion
Course syllabus
Week 1 — Idea to spec and foundations
Make your idea buildable.
- Cohort kickoff (Mon, 30 min): what "shipped" means and how to scope for it
- Optional: installation and setup office hours (Tue/Wed): environments working for everyone
- Live session: scope and spec (Fri, 90 min): cut your idea to a buildable v1; write a spec Claude can execute; set up context files
- Homework: your v1 spec
Week 2 — Build the first version
Get something running.
- Lab #1: first working build (Mon, 60 min): stand up your app's first version live
- Optional: office hours (Mon)
- Live session: iterate and troubleshoot (Fri, 90 min): refine by asking; learn to read and fix errors
- Homework: a running first version
Week 3 — Data and logic
Make it actually useful.
- Lab #2: add data and functionality (Mon, 60 min): connect data, add forms, logic, an agent step
- Optional: office hours (Mon)
- Live session: common-failure clinic (Fri, 90 min): work through the sticking points that trip up first builds
- Homework: a genuinely usable version
Week 4 — Ship and demo
Put it in front of a real person.
- Lab #3: deploy to production (Mon, 60 min): get your app live so others can use it
- Optional: office hours (Mon)
- Live session: demo day + what's next (Fri, 90 min): public demos, feedback, and how to keep going solo
- Deliverable: a live app a real user can open, plus a demo recording
Schedule
- Live sessions: about 2 hrs/week, plus optional office hours
- Building your app: 3 to 5 hrs/week
- Total: about 5 to 7 hrs/week over 4 weeks
FAQ
Can a non-technical person really ship an app in four weeks? A focused v1, yes. That's the whole design of the cohort. We keep scope tight so you finish with something real instead of half of something ambitious.
What kind of app can I build? Focused tools work best: an internal app, a simple product, an AI-powered utility, a workflow tool. We help you pick an achievable scope in Week 1.
Do I need to know how to code? No. You direct the build and make product decisions; Claude writes the code. You pick up real fluency along the way.
How is this different from the website cohort? Websites are marketing sites: pages, booking, payments. Apps have logic, data, and user interaction. Different deliverable, different course.
What if I miss a session? Recorded and yours for life; async support covers hands-on gaps.