In the announcement post I made the case that the AI writing your code isn’t your problem; everything around the code is. This post gets specific about that, and then gets you set up to do something about it. It’s the first real lesson in The Workflow, and it’s the one that costs you almost nothing to follow along with.
If you’ve ever built anything with an AI chat assistant beyond a one-off script, the failure I’m about to describe is going to feel uncomfortably familiar. That’s the point. Naming it precisely is what makes the fix obvious later.
The three seams
The copy-paste loop (describe, copy, paste, run, paste the error back, repeat) doesn’t fail all at once. It fails at three specific seams. Once you can see them, you can’t un-see them.
Seam 1: More than one file
The moment your project is two files instead of one, the chat window loses the thread. You paste in cli.py, ask for a change, and the AI confidently edits it, except the change actually needed to touch tasks.py too, which it never saw because you only pasted one file. Or you paste both, and now its reply rewrites both and you’re hand-merging two blobs of text back into two real files.
Either way, you become the integration layer. Every change is a manual diff you perform in your head, between what’s in the chat and what’s on disk. It’s slow, and worse, it’s error-prone in a way you can’t see: there’s no record of what actually changed.
Seam 2: More than one day
Close the chat tab, come back tomorrow, and the AI’s entire working memory is gone. It doesn’t know what you decided yesterday, which approach you rejected, or why that one function looks weird (you had a reason; past you knew it, present you doesn’t).
So you re-explain. You re-paste. You reconstruct yesterday from memory, and your memory is worse than you think. The project’s real state is sitting right there on your disk, but the chat has no way to read your disk, so every session starts cold.
Seam 3: No undo, no record, no safety
This is the quiet one, and it’s the most dangerous. When the AI confidently makes a mess (deletes a function you needed, “refactors” something into a subtly broken state, rewrites a file you’d carefully tuned), what’s your recovery plan?
Right now it’s probably Ctrl-Z until it looks right, or paste the old version back from the chat history if I can find it, or, too often, retype it from memory. There’s no checkpoint to return to and no record of what changed between “working” and “broken.” And here’s the kicker: the AI makes it easier to do a lot of risky changes fast, which means you fall more often, not less.
Notice what they have in common
None of these three are about the AI’s intelligence. A smarter model writes better code, but it doesn’t hand you a record of changes, a way to undo a mess, or a memory that survives a closed tab. Those come from the engineering scaffolding around the model: version control, a real editor integration, hosting, review, automation.
That’s the whole course. And the pain you already feel is the curriculum; every tool I’m going to show you exists to close one of these seams.
Getting set up
Talk is cheap, so let’s stand up a real workspace. The good news: the entry requirements are almost nothing. You need to be comfortable using an AI chat assistant, and you need a machine you can install software on. That’s it. If you’ve barely touched a terminal, this’ll stretch you, but every command in the course is shown and explained, so it won’t lose you.
Here’s what to get in place. You’ll use all of it for the rest of the course.
A terminal. Terminal on macOS or Linux; Windows Terminal or PowerShell on Windows. (A heads-up for Windows folks: the labs’ shell snippets are written for bash, so running them from Git Bash or WSL is the smoothest path.)
A code editor. Any will do, but a graphical one like VS Code is the easiest starting point; later modules build on editor-integrated AI tools, and VS Code is the path of least resistance there.
Python 3.10 or newer. The labs are written with python3, the command current macOS and default Ubuntu actually ship (they install Python only as python3, with no bare python on PATH). Check with python3 --version; if it prints a 3.10+ version, use python3 everywhere from here on. If python3 says “command not found” but python --version shows 3.10+ (older or some Windows setups), just read every python3 in the labs as python instead.
Your usual AI chat assistant, open in a browser tab. Any of them. Remember: model-agnostic.
[insert a screenshot referencing VS Code + terminal + the tasks-app project open here]
Grab the course materials
Everything you’ll run lives in one repo. Grab it once, up front; no tools required beyond a web browser. Open the course home page at https://git.jpaul.io/justin/ai-workflow-course, use its Download ZIP link, and unzip it under your home directory so the modules/ folder lands somewhere tidy like ~/ai-workflow-course/modules/.
That’s it: you now have every module’s files locally, including a small running example app called tasks-app that the whole course is built around. (There’s a cleaner, updatable way to get the repo, git clone, but that arrives a couple of modules in, once you’ve actually learned Git. A one-time ZIP is all you need today.)
Feel the problem on purpose
Here’s the part I actually want you to do, because reading about the three seams is nothing like feeling them. Stand up the example app, then reproduce each failure deliberately, keeping the AI strictly in the browser chat, no editor integration yet. This is the “before” picture, on purpose:
- Seam 1. Paste only one file into your chat and ask for a change that really belongs in another file. Watch the AI guess, because it can’t see the file it actually needed.
- Seam 2. Close the tab. Open a new one. Ask it to “continue where we left off.” Watch it have no idea, while your project’s real state sits untouched on your disk.
- Seam 3. Ask it to “refactor this to be cleaner,” paste the result back over your file without reading it, then try to get back to the exact version you had five minutes ago. Notice your only options are fragile editor-undo and digging through chat history.
You just manually reproduced the three problems the rest of the course removes. Hold onto that feeling; it’s the motivation for everything that follows.
Where this breaks (because I like to be honest)
A few caveats, because I’d rather you trust me than oversell you:
- **Copy-paste isn’t wrong, it’s unscalable.** For a one-file throwaway, the loop is genuinely the fastest path. Don’t bring a CI pipeline to a five-line utility. The toolchain earns its keep as soon as a project has a second file or a second day, which is most of them, but not all.
- Tools don’t fix judgment. Version control will let you undo a bad AI change instantly; it won’t tell you the change was bad. Reviewing AI output is its own skill (its own module, later), and no amount of scaffolding replaces it.
- This won’t make you faster today. Setup rarely does. The payoff compounds over the next several modules. If it feels like overhead right now, that’s expected.
You’re done when
You can run the example app in your terminal and see output: your project, editor, and terminal working together. You can name the three seams without looking back. And you can state the thesis in your own words: the model is swappable; the workflow is the durable skill.
If all three are true, you’re set up, and the next post installs the single most important thing in the whole course: the safety net that makes everything riskier after it safe to attempt. (Spoiler: it’s Git, but probably not the way you’ve been told to think about it.)
Following along? Tell me where you’re getting stuck in the comments; I read them, and the rough edges you hit are exactly what makes the course better.
