<!--
Suggested title:    The Copy-Paste Problem (and How to Actually Get Started)
Alt title:          Three Places the AI Chat Loop Breaks, and the Setup That Fixes It
Slug:               the-workflow-getting-started
Meta description:   Part one of The Workflow. The chat-to-file copy-paste loop breaks in
                    three specific places. Here's where, why, and how to set up a real
                    workspace to start fixing it.
Tags:               AI, developer workflow, getting started, terminal, VS Code, Python
-->

# The Copy-Paste Problem (and How to Actually Get Started)

In the [announcement post](https://git.jpaul.io/justin/ai-workflow-course) 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](https://git.jpaul.io/justin/ai-workflow-course), 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:

1. **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.
2. **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.
3. **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.
