Build and launch a real software product with AI — in six weeks.
This is not a coding class or a business class. It's a builder apprenticeship. You'll learn a repeatable loop for turning problems into shipped products, then prove it by shipping one yourself. Everything you need — process, tools, links — is on this page.
Build and launch a useful product using AI, and learn a process you can repeat on your own. By the end, you should be someone who turns ideas into working software — and knows when to keep going and when to quit.
Every project runs the same nine steps. Run it until it's second nature. The two steps most beginners skip — Validate and Decide — are exactly the ones that separate shipped products from abandoned ones, so this handbook gives each its own section.
Watch real life. Friction is everywhere if you look.
Write down the pain in one sentence. Aim for 50.
Get real commitment before you build. See §05.
Name the product, the user, the smallest useful version.
Ship an MVP in 2–6 weeks with AI tools.
Find bugs and edge cases. Use AI as QA.
Put it in front of real users through one channel (see below).
Wire analytics from day one. Watch what people actually do.
Scale it, fix it, or kill it. See §09.
You'll see "pick one channel" a few times. A channel is how people find out your product exists — your one repeatable way of getting it in front of new users. That's distribution, and it's a separate problem from building the thing. A great product nobody can find still fails.
Examples of a single channel: posting in one specific subreddit where your users hang out · making short videos on TikTok or YouTube · being active in one Discord or Facebook group · SEO (showing up in Google for a search people already make) · cold email/DMs to a specific type of person · listing on a marketplace like an app store.
Why one? Each channel is its own skill that takes time to get good at. Beginners spread across five and do all of them badly. Pick the single place your users already gather, get good at reaching them there, and ignore the rest until that one is working.
You're the founder. AI is your staff. The skill isn't typing prompts — it's explaining what you want clearly: give each "teammate" the background, the rules, and the goal, just like you'd tell a real person. (You’ll work in ChatGPT — every role here can run there.) Prompting tips →
Markets, competitors, idea generation, "what am I missing?"
Define features, cut scope, write the plan, decide what comes first.
Generate layouts and screens — but you own taste. AI helps, you decide.
Build features, fix bugs, explain code you don't understand yet.
Find issues, write test plans, hunt for edge cases before users do.
Launch copy, summaries, content for your one channel.
Use AI for engineering, research, and first drafts. Don't outsource taste on anything users see — design, naming, the core feel of the product. That's the founder's job, and it's the thing AI is worst at. Decide; then let AI execute.
Here's the toolkit. You don't need all of it on day one — start with the required tools and add the rest only when a project actually needs them. Most of it has a free tier that’s plenty for a first build.
If the intern is enrolled in school (13+), apply for the GitHub Student Developer Pack on day one. It bundles dozens of paid tools for free while verified — including GitHub Copilot Pro, JetBrains IDEs, cloud credits, and a free domain via Namecheap. Verification with a school email is usually instant.
Your everyday thinking partner: research, planning, QA, writing, and help with bugs. This is home base for the whole team-of-AI workflow. A ChatGPT Plus plan covers it (and includes Codex below).
OpenAI's coding helper. It reads your project, plans, and writes/edits the code for you — from the terminal, a code editor, or the cloud. It's included free in ChatGPT Plus (heavy days can hit a usage cap; if so, use Copilot or Cursor below as a free backup).
Source control + your public portfolio. Every project lives here with a README and screenshots. GitHub Pages can host static sites for free.
One-click deploy and hosting. Connect your GitHub repo and every push goes live at a public URL — that's how you get the "public URL" deliverable. The free tier is plenty for an MVP.
The default web framework for AI-built apps. The free interactive course is the fastest way to learn it.
A Postgres database in the cloud, for when your app needs to save things (scores, sign-ups, posts). Your first MVP may not need a database at all — add it only when you do.
Describe a UI, get working React. Great for first drafts and landing pages. (Formerly v0.dev.)
Take real money. Use test mode while building. Charging early is a feature, not a milestone — see §05.
Add AI to your product without locking to one provider. Swap models freely; survive a price change.
An AI-powered code editor. A good backup or companion to Codex if you prefer writing code in an editor instead of the terminal.
See what users actually do. Wire it in before launch, not after.
One home for all your writing: the Problem Bank, the briefs, the product plan, and your daily Builder Journal. Keep everything in one place instead of loose docs.
A simple to-do list for your code, built right into your GitHub repo. Write down each bug or feature as an "issue," then check it off. That's all the task-tracking a solo project needs.
Later, if you're curious: Linear is the task tracker professional software teams use. It's worth seeing once you've shipped something — but skip it for now. For a first solo build, a fancy tracker just slows you down. Tools should help you ship, not give you something to fiddle with instead of building.
Twenty minutes of housekeeping that saves hours later. Knock these out in week 1.
node --version to check, then set up Codex and sign in with your ChatGPT account..env file that is git-ignored — never pasted into code that gets pushed to a public repo.The biggest mistake beginners make is building something nobody wanted. Two tools stop that: a 60-second kill check to pressure-test an idea, and a validation rule to get proof before writing real code. Both come straight from the PlayLabs Playbook.
The test: if you can't get ~5 real commitments in two weeks of trying, the idea is wrong — not your marketing. Kill it and move on. "Would you use this?" surveys and free signups don't count. Only commitment counts.
When the intern graduates to scoring a serious idea (or a studio one), run it through the full PlayLabs rubric, not just this kill check — the Track A / Track B scoring and the founder comp table live in the studio playbook. The kill check is the fast filter; the rubric is the real decision.
Eight artifacts by the end of six weeks. Check each as it's done — your progress bar at the top tracks the whole handbook.
Each week has one win condition. Hit it before moving on. Check the box when you do.
Set up accounts · create GitHub · get Codex running · deploy your first "hello world" · understand the AI workflow.
Observe real life · collect 50+ problems · learn to spot opportunities · narrow to your top five.
Run ideas through the kill check (§05) · validate with real commitment · write the Opportunity Brief and Product Plan · define the MVP.
Build with AI · deploy continuously · wire analytics from day one · solve problems independently (ask AI before giving up).
Find testers · watch them use it (don't explain — just watch) · fix the top problems · ship v2.
Public launch on your one channel · final docs · write the blog post · deliver the presentation.
A simple rhythm. The goal of every working day: one meaningful improvement to the project. The check-ins below are short and focused — they're for unblocking you, not status theater.
Quick sync with your mentor: what you're working on, any blockers, today's single goal. Held three times a week, never more than 30 minutes.
Independent work. Move the project forward by at least one real step. This is where most of your time goes.
Wrap-up with your mentor: what happened, what you learned, what's next. Pairs with a standup day.
Then: a journal entry in under five minutes — build / learn / stuck, one sentence each.
Week 1 — in person. Every standup and review happens face-to-face while you're learning the tools and the workflow. This is the highest-bandwidth week; use it.
Weeks 2 onward — mostly async, with a live anchor. Standups and reviews can move to async (post your goal + blockers, and your wrap-up, in a shared doc or chat). The one rule: at least one standup and one review each week must be live (call or in person). Async keeps you moving; the weekly live sync catches the things writing misses.
The non-negotiables are the daily journal and the daily "one meaningful improvement." Protect those.
The loop ends in a decision, made on evidence. Most projects should be killed — that's normal and healthy. Experienced builders ship many and quit fast; a ~5% hit rate is the rule, not a sign of failure. The skill is killing without grief.
You don't have to make this call from your gut. We built a custom GPT inside ChatGPT — the PlayLabs Playbook — and it's been shared with you. Feed it your product, your evidence, and where you've landed, and it'll run the idea through the full framework: the kill check, the deeper scoring, and a keep / wait / kill verdict with reasoning.
Treat it as a sharp second opinion, not the final word — it's there to pressure-test your thinking and surface what you're missing. You and your mentor still make the actual decision. Bring its verdict to your review.
For the internship, "shipped and learned" is the win — not "made money." A killed product with a sharp blog post on why it died is a successful internship. Falling in love with the idea kills more projects than any technical mistake; name the kill criteria before you build, so the decision is honest when it arrives.
Ship before perfect.
Ask AI before giving up.
Learn by building.
Problems matter more than ideas.
Validate with commitment, not opinions.
Pick one channel (one way to reach users). Obsess.
Public work creates opportunities.
Document everything.
Finish what you start — or kill it on purpose.
Niche down. "Everyone" is nobody.
Everything in one place. Bookmark this section.