Ship software real people sign in to and use.

Learn the way production software is built. With an AI assistant as your team, one person can build what used to take several — you lead, it builds, and every project ships. A one-to-one course of 36 live classes with Robert Cushman, three a week, planned over approximately 12 weeks.

Production-ready is the bar, and it is specific: safe to put in front of real people, secure about who can see what, and durable through a restart, a redeploy and a bad release. The AI writes the code. You decide what gets built, say it precisely, and prove it meets that bar before anyone else touches it.

The commitment

A fixed shape, so you can see what you are buying

Length
~12weeks, at your pace
Classes
36private, one-to-one
Cadence
3 / wkabout 60 minutes each
Practice
100minutes after each class
Projects
4each one finished and released
Reviews
3at classes 12, 24 and 36

Classes run on the America/Mexico_City calendar and are delivered over Google Meet. The 36 classes are planned over approximately 12 weeks and paid month by month. When a lesson needs a second class, it gets one: the calendar moves instead of the lesson being rushed.

The full stack

Every layer of a real application, from the first screen to the release

This is an introductory course, and a complete one. You work with the standard languages and services of modern web development at every layer, and you run the whole software life cycle: decide, specify, build, test, release, recover. The next level after this is depth in one language or framework. This course gives you the whole picture first, so you know exactly where that depth belongs.

01The screen — pages that work on a phone and with a keyboard, built from reusable componentsHTML, CSS, JavaScript, TypeScript, React
02The server — routes, validation, and a sensible answer to a bad requestNode.js, Express
03The data — records that survive a restart and a redeploy, in a managed Postgres databaseNeon Postgres
04Sign-in — managed authentication, including Google single sign-on, with no hand-rolled passwordsClerk
05Permission — once you sign in, your role decides what you can reach: your own records, and admin-only actions. Enforced on the server, not taken on trust from the browserOwnership and roles
06Version history, tests that guard what must keep working, and automated checks that run when the code changesGitHub, Vitest, CI
07Release — continuous deployment, a live check after every release, and a rollback when one goes wrongVercel

You do not write a deployment pipeline from scratch. You learn to read the automated checks, rely on them, and tell when they have caught something.

What you build

Four projects, each one finished rather than abandoned

Most side projects stall after a feature or two, once the interesting part is over. This course is designed so yours ship: every class adds one visible feature, and every project has a week it is due. The first, the Music Theory Quiz, is live with Google sign-in by class 9, with two real players comparing totals on their own devices.

01

Music Theory Quiz

You start from a working quiz and turn it into a real contest — music theory, or any subject with facts you can check. It goes live on the internet: players sign in with Google, the server protects every score from being faked, and only an admin can reset the leaderboard.

Planned for week 3
02

Reading List

Track the books you want to read, are reading and have finished, saved to your account. The search pulls from a real public catalogue, so the real lesson is what to show while waiting, and when no answer arrives.

Planned for week 5
03

Lesson Booking

A music teacher's booking app: clients book lessons, the teacher manages the calendar, and an admin runs it. Postgres on Neon, Google sign-in through Clerk, and a server that never double-books a lesson.

Planned for week 9
04

Your own application

One real problem, for one real person, chosen by you. Scoped, built, tested, deployed, documented, and improved after watching someone use it.

Planned for week 12

The final project may extend an earlier one. Four milestones do not mean four unrelated applications started from nothing.

The point of it

What you will be able to do, and why it lasts

The art of the possible. With an AI coding assistant as your team, one person can build what used to take several. The first thing you learn here is how far that really goes. The second is what it takes to make the result hold up.

The way production software is built. Vibe coding gets you a demo. What hobbyists and vibe coders rarely see is everything behind a release: version history, automated checks on every change, a real database, sign-in with Google, roles enforced on the server, tests, and a release you can roll back. That is the core of this course, not an extra.

Finishing. Four projects released, none of them abandoned after the second feature.

The way teams work. Sprints, a written spec, review and sign-off — the rhythm of a product team, with the AI as the team and you leading it.

Underneath all four, the goal is narrow and testable: you should understand the software you create well enough to explain it, change it, troubleshoot it, and judge whether it actually works. Everything in the course is arranged around that sentence.

Following what the code does

Break a problem into steps, say what a piece of code should do before running it, and spot what is wrong in it, so the code your AI writes stops being a black box.

Software construction

Connect the screen, the logic, the service it talks to, and the data it stores — and know which one broke.

Working with AI

Have one AI write the spec and the prompt, find every decision it made for you, check its facts with a second AI and a real source, and refuse anything you cannot explain.

Professional habits

Version history on GitHub, tests, automated checks, continuous deployment and rollback — the practices that make work reviewable and a release reversible.

Protecting what you build

Sign-in, roles that decide who may see or change a record, server-side checks on every request, and how to get the data back when something goes wrong.

Finishing things

Taking a project past the second feature, through the parts that are no longer exciting, to a release people actually use.

The shift this is really buying

Where most self-taught AI users stop Where you are headed
Describes what it should look likeDefines behaviour, data, and what counts as working
Accepts code because it looks plausibleChecks the assumptions and verifies the result
Asks for another rewrite when it breaksReproduces the failure and isolates the cause
Repeats the AI's explanation backTraces it yourself and makes a change you have not seen before
Treats generated code as finishedTests it, documents it, ships it, then checks the release
Adds another tool when unsureChooses the simpler approach when it is enough
Stops at the demo that workedShips it live with sign-in, permissions and a way back

The left column is not a failure — it is where almost everyone lands after teaching themselves with an AI assistant, and it works right up until something breaks and there is no one to ask. The right column is the part that keeps its value as the tools keep changing.

How you will be working

You run the product. The AI is your team.

This is how product teams work: a backlog, sprints, a spec, review and sign-off. The difference is that your team is an AI assistant, and you lead it.

You are the product owner, the project manager and the IT manager. The AI assistant is your developers, your database administrator, your security reviewer and your tester. You decide what gets built, have the AI turn that into a precise brief, audit what it decided, and sign off only on what you can prove works.

In every sprint there is a step only you can take: a decision the AI is not allowed to make for you. What counts as right, what must not change, and whether it is finished — those are yours, every class, and they are what the course is really teaching.

That ratio is deliberate, and it is roughly what the work looks like in practice. The tasks below have names outside a classroom, and you practise all six.

Product owner

Turning "I want an app that does this" into three observable conditions that say whether it worked — and cutting the idea down to the three features that matter.

Quality assurance

Trying to break your own application on purpose: empty input, duplicate actions, invalid IDs, a service that does not answer. Then writing the test that stops it happening twice.

User experience

Watching a real person use what you built without helping them, then separating what genuinely confused them from what they merely suggested.

Project manager

Working from a small backlog, tackling the riskiest assumption first, and explaining what a late change does to time and scope instead of silently absorbing it.

Reviewer

Checking what actually changed — in your own work or an AI agent's, as closely as you would review a teammate's — and refusing anything you cannot explain, including files and dependencies that appeared without being asked for.

Owner of a live system

Releasing it, knowing which version is running, restoring data after a mistake, and writing down what it costs and who maintains it.

These are not extra subjects layered on top of the coding. They are what the coding is for, and they are the part of the work that does not get cheaper as the tools improve.

The 12 weeks

Where the program goes, and where it stops to check

01A working quiz you change and check, playable on a phone, with a question bank you verifiedFirst working prototype
02Git and GitHub, a three-round contest, every change through a checked pull request, and tests that guard scores and levelsRun like a team
03A shared server, Google sign-in with an admin role, and a first public releaseProject 1 live
04Reading data from another system; handling waiting and failureFirst review
05Organising an interface into components and managing its stateProject 2 live
06Your reading list follows you to any device after sign-in; Lesson Booking starts with your own API, which refuses bad bookingsFrontend meets backend
07A real database — saving, changing and protecting recordsData that survives
08Identity versus permission, and proving a stranger is refusedSecond review
09Releasing the full system, directing a coding agent, maintaining itProject 3 live
10Choosing your own problem and building one complete workflowCapstone begins
11Adding features without breaking the first, then watching a real userTested candidate
12Final release, written handover, and an unrehearsed change made liveFinal review

The three highlighted weeks are progress reviews. You demonstrate your own work, say without AI exactly what a change you have not seen before requires, and talk through a bug you have to find. You receive a written summary after each one.

Why this course

Ten reasons to take it

Each reason is something the course has you do, and what it leaves you with when you put in the work.

Four projects, all finished

A quiz, a reading list, a booking app and an application of your own, each released to real users before the course ends. You leave with working software you can show and explain, not a folder of half-done tutorials.

One-to-one, taught live

Three classes a week with Robert Cushman, built around your project and your questions. Nothing gets skipped because a group moved on.

An AI team that you lead

Your AI coding assistant writes the code; you decide what gets built, in what order, and what is good enough. You learn to get the work of several people out of one assistant, and to stay in charge of it.

A method that catches the AI's mistakes

Every sprint runs the same four steps: say what you want, have the AI write the spec, audit what it decided for you, then check the result yourself. You learn to spot a confident wrong answer before it ships.

The habits production teams use

From the second week: version history on GitHub, changes that arrive as pull requests, an automatic check on every change, and tests. Your changes become something you can review, trust and undo.

The whole stack, built by you

A React frontend, an Express API and a Postgres database, connected by you. When something breaks, you can tell which part broke and why.

Security you can prove

Sign-in with Google, roles checked on the server, and a test that proves a stranger is refused. Your apps are built so each person sees only what they are allowed to see, and you have checked it.

Real people use what you build

Two real players try your quiz on their own phones, and a real person tries your final app. You fix what tripped them up, which is how products actually get better.

Reviews that show what you understand

Three progress reviews ask you to explain your own work, say without AI exactly what a change you have not seen before requires, and find a bug. You know what you have mastered, and what to work on next.

Software someone else can run

The course ends with a release checklist, a README and a runbook that another person, or a fresh AI session, can follow to run and recover your app. What you build does not depend on you remembering how it works.

Inside one class

Sixty minutes, one feature shipped

  • Last class, checked5 min
  • Set up the sprint5 min
  • Sprint one20 min
  • Sprint two25 min
  • Show it working5 min

Every sprint runs the same four steps. You say what you want. The AI writes the spec. You audit what it decided for you. Then you check the result yourself, and nothing ships until it passes. By the end of the hour your product does something it could not do when the hour started.

Before starting

What you need to bring

Required

  • 18 or older. The AI tools this program depends on set their own minimum age, and we confirm eligibility before any payment.
  • Some prior code. A web page, a script, a tutorial project you actually typed and changed. You should be able to read a short piece of code and say roughly what it does.
  • Some AI experience. You have used an assistant for something real, and have noticed that it can be confidently wrong.
  • A paid Claude or ChatGPT subscription for the full course — one, not both. We confirm the specific plan works before you buy it.
  • A computer you can install software on, reliable internet, a microphone, and the ability to share your screen.
  • 9 hours a week, including classes, assigned practice, and three short next-day sessions. Keep one rest day. The practice between classes is the larger half, and it is not optional.

Setup is part of the course. If you already develop, you get a short checklist. If you have never set up your own machine, Class 0 shows you how to have the AI walk you through installing a code editor, Node.js and your coding assistant, one step at a time.

Not required

  • Professional or paid development experience
  • A computer science degree or a bootcamp
  • Any knowledge of React, databases, or version control — all taught from the beginning
  • A finished or portfolio-ready project
  • Paid hosting or API accounts before starting

Paid separately

  • The AI subscription
  • Hosting, domains and any paid interfaces the final project needs
  • Hardware and general computer repair

If someone else is paying: they receive scheduling, payment and attendance information. Your coursework, scores and the content of our conversations stay private to you unless you say otherwise.

How you will know it is working

Attendance is not the same as ability

At each of the three reviews, you are scored on nine specific things — explaining code, specifying a change without AI, finding a bug, judging an AI suggestion, tracing how the parts connect, testing, releasing, and recovering when something breaks.

Each is marked on a four-point scale, from cannot yet do this to does it independently and can say why. You get the scores and the reasoning in writing after each review.

At the end, two separate documents

  • A completion record. Attendance at a minimum of 30 of the 36 classes, all milestone work submitted, all three reviews completed.
  • A skills report. What you can do on your own, what you can do with documentation or a hint, what still needs help — and which of your own projects is the evidence for each judgment.

The second document is the useful one. Someone can attend every class and still need substantial help, and you should be told that plainly rather than handed a certificate.

Worth saying plainly

What this program does not do

  • It does not qualify you for a software engineering job, and I will not suggest otherwise.
  • It is not a professional certification or an accredited qualification.
  • It does not make you a security specialist or an infrastructure engineer. Sign-in, the database and hosting run on managed services; you learn to configure them, check them and rely on them.
  • It will not turn you into a senior developer in twelve weeks. Nothing does.
  • Payment and attendance do not guarantee a passing assessment.
  • If you are not engaging with the work, I will say so early rather than at the end.

What you will have is software real people have signed in to and used — software you can explain, change deliberately, and prove works — plus an honest account of where you are strong and where you are not. That is a real foundation, and it is what the next stage, depth in one language or framework, is built on.

Who teaches it

Robert Cushman

I am a full-stack developer and the founder of CushLabs AI Services, based in Guadalajara. Before that I spent my career in enterprise IT — leading technology projects inside a Fortune 500 manufacturer, and earlier doing IT consulting work with Kodak and Corning.

I teach this the way I ship client work: small changes, tested, explained, committed and released. You will not be watching recorded lectures. Every class is live, one-to-one, and built around whatever you are actually stuck on that week.

  • Fortune 500 IT leadershipPraxair / Linde — 100+ global projects, 26,000 employees, 42 countries
  • Earlier IT consultingKodak and Corning
  • Building today50+ repositories, 2,100+ commits, 27+ production deployments
  • Based inGuadalajara, Mexico

Before anyone commits

The one thing I cannot supply

Everything else on this page is mine to deliver — the structure, the teaching, the feedback, the honest assessment at the end. This part is not, and I would rather say so now than discover it in week seven.

The program only works if you do the work between classes. Ninety minutes to two hours after each one, three times a week, for twelve weeks. That is more time outside the classroom than in it, and it is where the learning actually happens — the classes are largely where we repair whatever went wrong in the practice.

I cannot do the practice for you. I cannot supply the focus, or the wish to finish. If that follow-through is not there, no amount of structure on my side produces it, and pushing through anyway wastes your money and your time.

Week one is interesting because everything is new. Week seven is databases, and it is not. What you do in that week is what decides how this ends — and that comes down to commitment, not ability.

The honest framing is that this is a part-time job, or a real college course — 108 hours over the twelve weeks. Nobody becomes a software developer in twelve weeks, and I would not claim it. What this does is build a foundation you actually own, and foundations take the hours.

What the homework after each class is made of

Finish and checkWhatever the hour did not finish, finished and checked
RecallShort questions on the ideas the class used, answered from memory
Bring to the next classA short list of what you must be ready to do when it starts

Every class page says how long its homework should take. When the time is up you stop, and bring a note of where you stopped. Running out of time is information, not failure.

Next step

A conversation, not a test

The call I would like is not an assessment. No code, no questions you have to get right, nothing to prepare or revise for. I am not trying to catch you out.

I want to hear what you would actually want to build, and whether you are prepared to keep going once it stops being novel. That is the only thing I genuinely cannot judge from a document.

If it is a fit, I will tell you where I would start you and what I think you can realistically reach in 36 classes. If it is not the right time, I will tell you that instead — before you pay anything.