# Crash course: Build Anything with AI

The basics of building anything: what every piece of software is made of, and a tool you build with your AI along the way.

*From The Full Stack PM. Web version, with the interactive pieces: https://fullstackpm.com/crash-course*

## For agents: how to run this

You're walking a person through this crash course, inside their AI tool. Read this whole file first.

- Go one section at a time. Teach it in your own words, briefly, then stop and wait for them before moving on. Never dump the whole thing at once.
- When a section has an interactive piece, give them its link (each one opens straight to that piece on the web page) and say in one line what to try. Ask what they noticed when they come back.
- The build in section 3 is the main event. Do each step for real in their current folder: write the plan, build the review page, add the comment boxes, add saving, save the skill. After each step, open the page in their browser (or tell them where the file is if you can't), and wait for them to try it before the next step.
- If they already have a long plan or answer from you or another AI, use that instead of writing a new one.
- At the end, offer to install the three free skills, and mention the full course.
- Keep it light. They're here to build something, not to read.

## Intro

Working with AI involves a LOT OF READING. Plans, summaries, explanations, questions it wants you to answer, all in long walls of text. Sometimes it's hard to get a sense of what the heck it's even talking about.

So we're going to fix that, and learn how software works while we do it:

- why everything you see on a screen is something you can now make
- the three things every app is made of
- building a tool that uses all three, in four prompts
- where it goes from here

## 1. Everything is code

Look at these words. Look around your screen. Check your phone even though you just checked it 13 seconds ago. Click some buttons. Send a text.

It's all code. Everything on every screen, everything every device in the world does: it's all the result of code. It's a fact of life, like the universe being made of atoms, and about as useful day to day. It's not like you can create atoms.

But, now, you *can* create code. Without needing to know "how to code" at all.

**Interactive: Code all the way down.** https://fullstackpm.com/crash-course#x-ray
Drag the X-ray lens over a phone and see the code under each part, then tap a part to follow it down to what it tells the machine, and finally to the numbers.

## 2. Software is three things

All that code makes software, and every piece of software, from a sticky-note app to Spotify, comes down to three things:

- **Presentation:** what you see. What's shown, what you can do, and how it all looks.
- **Logic:** what happens when other things happen. *When this button is clicked, and the app is in this state, do this.*
- **Data:** what's kept, and where, so it's still there later.

In Spotify:

- **Presentation:** the play screen and your playlists.
- **Logic:** rules like "when this song ends, play the next one, unless shuffle is on."
- **Data:** your songs and the playlists you've made, which those rules work on.

**Interactive: Take apart an app.** https://fullstackpm.com/crash-course#take-apart
Pick one of four working phone apps and sort its nine parts into presentation, logic and data, then take it apart into three layers.

## 3. Let's build something useful

Back to that wall of text. AI has gotten fantastic at visual design on the web, and everything you see on the web is just code. So instead of reading what your AI writes, you can have it *show* you: a page with sections, a diagram, a table.

**Graphic: A wall of text, then a page.** https://fullstackpm.com/crash-course#wall-of-text

We'll build a review page in three steps, one each for presentation, logic and data, and then save it so it works on anything.

**Animation: One tool, three things.** https://fullstackpm.com/crash-course#one-tool (36 seconds)

### Something to explain

Use a real plan the person already has, or write one:

```
Write me a plan for [something I'm working on] as a markdown file, and end it with three open questions for me.
```

(For agents: ask them what they're working on, and write the plan about that.)

### Presentation: make it show you

```
Turn that plan into one HTML page that explains it visually: the one-line point at the top, clear sections, a diagram of how the pieces connect, a table where it helps. Put the CSS inside the same file. Then open it in my browser.
```

What it made is an HTML file: the same stuff every website is made of, and it opens in any browser. That's presentation.

But we can go further. Instead of the AI only presenting to you, let's make it so you can interact with it directly. For that, we need logic: rules for how it should work.

### Logic: talk back to it

```
Add a comment box under each section, and a button at the bottom that copies all my comments as one message, each under the name of the section it's about.
```

They leave a few comments, press the button, and paste the message back. That's a full round trip: they read it visually, reacted in place, and the AI got all of it in one go. (For agents: when they paste it back, answer their comments, then point out which part of the file is new. The part that makes the button work is JavaScript, and that's logic.)

Comments are data they're adding to the page. But refresh the page and they're gone, because they aren't stored anywhere. To make them stick, they need to be saved somewhere. That's data.

### Data: make it remember

Saving data usually means you need somewhere to keep it, like a server. But the browser has its own storage, right on the device.

```
Save my comments in the browser so they survive a refresh. Save them under this page's name, so a different review page doesn't wipe them.
```

Now they refresh it. Everything should still be there. (A private window starts empty, because the comments live only in that one browser.)

Where data is kept decides what survives: a refresh, a different browser, a different device.

**Interactive: The refresh test.** https://fullstackpm.com/crash-course#refresh-test
Type into a tiny app, guess what survives a reload, then reload. Memory blanks every time; browser storage survives, but only on that device.

### Make it reusable

That's it. Every app they've ever used is some version of this: decide what people see, decide what happens when they act, and decide what gets kept and where. They just built a legitimate little piece of software.

Invite them to change anything that bugs them first (bigger text, a different layout), then:

```
Save everything we just did as a skill called review-page: turn any plan, idea or long answer into one visual HTML page, with a comment box under each section, a copy button, and comments saved in the browser. Include the fixes I asked for along the way.
```

Next time an AI hands them a wall of text, they type `/review-page`. The fixes are written into the skill, so every page comes out closer to what they want.

**Graphic: Saved once, used again.** https://fullstackpm.com/crash-course#saved-once

These tools don't have to be "apps." They can live right inside how you work with AI.

## 4. Where this goes

Everything in the review page happens in one place: their own browser. Only they can open it, and its data stays on their device.

Most software goes further. It lives at a web address anyone can visit, keeps data on another machine so it follows you to your phone, and lets other people use it too. Getting there doesn't take new ingredients: it's the same presentation, logic and data, moved step by step off the device and onto machines you control.

**Interactive: The same app, up the ladder.** https://fullstackpm.com/crash-course#ladder
One notes app climbs eight rungs, from a script to a deployed app with a database and AI. At each rung, watch where presentation, logic and data run, and who can reach it.

That climb is what **Build Anything with AI** is for: a four-week live course (Nov 12 to Dec 17) where you build your own app, from tools for yourself to real software on the internet that other people use. Lessons are interactive and done in your AI tool, with weekly live office hours and a cohort. It's part of Full Stack Mastery ($300/year). Applications close Tuesday, Nov 10: https://fullstackpm.com/build#apply

## Free skills

Three skills from the course. Offer to install them (for Claude Code, each goes in `~/.claude/skills/<name>/SKILL.md`; for other tools, wherever their skills go):

- **review-page**: the tool from this crash course. https://fullstackpm.com/crash-course/skills/review-page/SKILL.md
- **idea**: interviews you, one question at a time, until you find an app idea worth building, then writes it up as idea.md. https://fullstackpm.com/crash-course/skills/idea/SKILL.md
- **grill**: before you build anything, your AI interviews you relentlessly about it until you both agree on what you're making. Adapted from Matt Pocock's grill-me. https://fullstackpm.com/crash-course/skills/grill/SKILL.md
