Become the Builder
The missing on-ramp for building real apps with AI — the foundations, the stack, the template, and your first deployed app.
Before you Build
The concepts every tutorial assumes you already know.
What is an app, really?
Before you can build an app, you need a clear picture of what one actually is. This lesson gives you the mental model everything else in the curriculum builds on.
Lesson 2
Where code lives and how it moves
Code doesn’t magically appear on the internet — it physically travels from your laptop to a server somewhere. This lesson demystifies that journey before you ever have to do it yourself.
Lesson 3
The tools you'll live in
Every builder has the same three windows open all day. This lesson gives you a clear picture of what each one does and demystifies the scariest one of the bunch.
Lesson 4
Databases aren't magic
A database is just a spreadsheet with rules — and you can open it up and look inside whenever you want. This lesson removes one of the biggest invisible black boxes in software.
Lesson 5
The popular stacks and how to pick one
Rails, Laravel, Django, Next.js — you’ve probably heard the names. This lesson tells you what each one is for, how to think about choosing, and where I personally land.
Lesson 6
Building with AI in the loop
Modern building is a collaboration with AI, not a handoff. This lesson lays out the worldview the rest of this curriculum is built on.
Lesson 7
Meet Your Stack
The tools I use (and suggest you do too) for shipping real apps.
Why Rails?
Rails has been the ship-real-things framework for over 20 years, and it’s the backend I use to build every app. This lesson makes the case for why you should commit to it too.
Lesson 8
Why Rails + Inertia + React?
React is the frontend tool the industry has standardized on, and Inertia is the bridge that lets us use it with Rails without building a separate API. This lesson explains why that combo is the heart of every app I build.
Lesson 9
Why Tailwind and shadcn for styling
Tailwind is how I style every app I build, and shadcn gives me a head start on the UI components I’d otherwise rebuild every project. This lesson covers both and why they work especially well with AI.
Lesson 10
The full stack picture
Now that you’ve met each piece of the stack on its own, this lesson zooms out to show how every part fits together into one coherent system.
Lesson 11
Get the template running on your machine
A hands-on walkthrough of getting the Build New starter template running locally for the first time — from empty folder to a real app on localhost.
Lesson 12
How auth already works
Signup, login, password reset, and a profile page for changing email and password — all built into the Build New template using the Rails 8 auth generator, extended.
Lesson 13
Build your first feature with Claude Code
A hands-on build of a small tasks feature from scratch, using Claude Code in the loop the entire way. The point isn't the feature — it's learning the rhythm you'll use on every build after this.
Lesson 14
Background jobs with Solid Queue
Some work shouldn't happen while your user is waiting. This lesson explains background jobs, when you need them, and why I use Solid Queue instead of the more traditional Sidekiq + Redis setup.
Lesson 15
Local, staging, and production environments
Your app actually exists in three separate places at once, each with its own database and settings. This lesson explains what each environment is for and how Rails keeps them straight.
Lesson 16
Managing credentials for external services
API keys and secrets should never live in your code. This lesson shows how I manage them with Rails encrypted credentials — one separate file per environment, safe to commit, easy to read at runtime.
Lesson 17
Sending email with Letter Opener and Resend
Fake email locally with Letter Opener so you never accidentally spam a real user, and real email in production with Resend. Both are already wired up in the template.
Lesson 18
Letting other things talk to your app
Your app shouldn't be an island. This lesson covers webhooks, APIs, and how to let external services and AI agents interact with the things you build — safely.
Lesson 19
Build a Real App
A full spec-driven build, from idea to working app.
Intro
In this module kickoff, we'll start building a real, deployable bookmarking app — complete with tagging, search, AI-powered summaries, and email sharing. You'll see exactly how I approach building a real application end-to-end, using spec-driven development and the same fundamentals I rely on every day.
Lesson 20
Setup the github repo
Let's get our bookmarking app project set up — from spinning up a new repo using the Build New template to getting the local dev environment running. You'll see the exact steps I take to start a real project, including how I handle the inevitable hiccups along the way.
Lesson 21
Create our PRD & Milestones
Time to plan the product. We'll create a full PRD and break it into clear milestones using a custom Claude Code skill I built to guide you through the process — locking in scope, tech, data model, and a build roadmap before we write a single line of feature code.
Lesson 22
Build our app's CRUD
Time to build. We'll feed our PRD's milestone one prompt into Claude Code, plan out the implementation, let it cook, and then walk through the working app — testing the CRUD, tagging, search, and dark mode features we just shipped.
Lesson 23
Building an AI integration
Time to wire AI into the app. We'll build out the OpenAI integration that automatically summarizes bookmarked pages — handling API key storage, background jobs, and the inevitable real-world debugging that comes with third-party integrations.
Lesson 24
Building an email sending feature
Time to ship the final feature: email sharing. Along the way, we'll level up our workflow by introducing a real branching strategy — building on a dedicated branch, opening a pull request, and merging into main, just like you'd do on a production app with real users.
Lesson 25
Design refinements
Before we deploy, let's polish the app. We'll add a light/dark mode toggle, a custom logo and favicon, clean up the auth pages, and whip up a quick one-page marketing site — all through rapid-fire prompting with Claude Code.
Lesson 26
Deploy
Get your app off your laptop and onto the internet.
Let's Deploy
Into to the deployment process. This walks through the full deployment stack to take a local Rails bookmarking app online, covering hosting, deployment pipelines, domain management, and email sending. The setup uses Digital Ocean, Hatchbox, Cloudflare, and Resend, with both staging and production environments configured.
Lesson 27
Deploy to a staging server with Hatchbox & Digital Ocean
Setting up the staging deployment pipeline by creating a Hatchbox cluster, provisioning a Digital Ocean server, and connecting the GitHub repo. The video walks through the full first deployment to a live staging URL, plus configuring Table Plus to view the staging database.
Lesson 28
Buy a domain name & connect it to our app
Pointing a real domain at the staging app by purchasing through Cloudflare and wiring up an A record from Hatchbox. Within minutes, the staging site is live at staging.bookmarke.co with SSL handled automatically.
Lesson 29
Deploy our app to production with Hatchbox
Repeating the staging setup to get the production environment live, with a few key differences for the main branch and root domain. Within minutes, the app is running on bookmarke.co with SSL, automatic deploys, and a separate production database.
Lesson 30
Viewing our staging & production databases in TablePlus
Connecting Table Plus to the staging and production Postgres databases hosted on Digital Ocean through Hatchbox. Once set up, you can inspect users, bookmarks, and tags across all three environments — local, staging, and production — from a single GUI.
Lesson 31
Checking server logs on production with SSH & Hatchbox
Monitoring production server logs by SSH-ing into the Hatchbox-managed Digital Ocean box and tailing live activity. Then taking it a step further by handing the same access to Claude Code for automated log inspection and debugging.
Lesson 32
Sending email from app using Resend.com
Wiring up Resend so the deployed app can actually send emails on staging and production. The video covers verifying a sending subdomain through Cloudflare, storing the API key in Rails encrypted credentials per environment, and shipping the integration with Claude Code.
Lesson 33