Stop after two tries, reload, start fresh¶

Verified: 2026-10-13

In developers' words: The error message, reset to a commit, a new conversation

By the end of this level you stop at the second failed fix, reset to v1-works, and start a new conversation that knows what the two tries were.

TIME: 4 MINPROMPTS: 3 + 4CODE: 0

The moment

"Stop after two tries."¶

The fix didn't work. You said "that didn't work, try again". It tried something else. That didn't work either, and now two other things are off. You are forty minutes and a chunk of credits in, and the app is further from working than when you started. Each try was built on the last broken one. That is how an evening goes, and the bill for it arrives anyway.

That is the loop, and developers have a rule for it: when a fix fails twice, stop. Read the error message, the line the tool printed. Reset to the last commit that worked. Start a new conversation that knows what the two tries were, and let it check one thing before it changes anything. The game would respawn you in the broken world; the course says load the save. Three sentences.

Why this matters

Each try is built on the last broken one¶

The third try is a fix of the fix. By then the AI is repairing its own earlier guess, in a conversation full of its own mistakes. It does not get smarter with each try. It gets further from the save.
"Try again" costs the same as "do it right". Every retry is paid for in credits and minutes, and the retries are the part of the bill nobody planned. Two tries is enough to learn something. More is the loop.
The error message says what killed you, and nobody reads it. It is the closest thing you have to the cause. Skipping it is choosing to guess.
You can't avoid it. "Error message", "reset", "new session": every tool prints the first, and every guide for getting unstuck says the other two. Better to learn the moves now, on a save, than at eleven at night on a broken app.
Four minutes now, or an evening later. After this, the second failed fix costs you three sentences, and the third try never happens.

The map

The level in one picture¶

1TWO DEATHS

one order, one try, built on the last

try 1: changed the form's submit
try 2: changed the email check; it printed
2Cannot read property 'email' of undefined
2 = STOPthe second failed fix is the stop

3THE SAVE THAT WORKED

working:v1-worksTue 6 Oct
the two tries were never saved

↺A FRESH RUN

it remembers nothing, so you tell it:

THE NOTE YOU CARRY

at v1-works · the error · tried 1, tried 2
"Don't repeat those."

One box per word: an attempt is 1, the error message is 2, the reset is 3, ↺ the new conversation and the note it gets.

Step 1

Stop at two, and read what it printed¶

This step is a stop, not a fix. Count the tries. At two, send this, and do not act on its guess here: you take the two tries and the error message with you to step 3.

Prompt: That's the second attempt at this and it still isn't working. Stop. Don't try a third thing. Tell me, in plain words, what each of the two attempts changed, and paste the exact error message if there is one.

✓ Two short descriptions, the exact message, and a guess at the cause. No message, it just doesn't work? Then what you see is the message: write down exactly what happens and what you expected instead, in your own words.

Before
Two tries, two failures, and the urge to say "try again".
▼
After the prompt
The error message and the two tries, in plain words. The note you carry.

Step 2

Reset to the commit that worked¶

Reset to v1-works, or the last tag you made, and the two dead tries never happened. They were never committed, so they go, and the original problem is still there, on its own, without the two new ones.

Prompt: Reset to the save point v1-works. Confirm every file is as it was there, and tell me if anything from the last two attempts is still around.

✓ A line saying you are at v1-works and nothing from the attempts remains. Open the app: the original problem is still there, the two new ones are gone. Something still around, like a setting or a new file? Ask "remove everything that isn't in the save point v1-works".

Before
Two failed tries sit on top of the commit. The app is worse than when you started.
▼
After the prompt
Reset done. The two tries are gone, and only the original problem is left.

Step 3

Start a new conversation that knows what the two tries were¶

A new conversation remembers nothing, so you carry the note: where you are, the error message, the two tries. The old conversation holds both failed tries and keeps reading them; the new one starts from your description. Replace each part in angle brackets, brackets included.

Every tool has one: a new chat, a new session, a "clear" command. Closing and reopening the project does it on most platforms.

Prompt: (in a new conversation) I'm at the save point v1-works. One problem: <what you see, pasted>. Two things have already been tried and didn't work: <attempt one> and <attempt two>. Don't repeat those. Tell me the one thing you'd check first, and check it before changing anything.

✓ One check, done, with what it found, before any change. The cause is often nowhere near the two things that were tried. If this try fails too, that is try one of a new pair: the rule starts again at v1-works.

Before
The old conversation, with both failed tries in it, and the AI reading them back.
▼
After the prompt
A new conversation with the note. It checks one thing before it changes anything.

Keep that rule. It is your two-deaths limit, and the one line on this page to remember: "two tries, then stop, reset to v1-works, and start fresh with the note".

Your turn

Die twice on purpose, then reset¶

v1-works is behind you, so let two tries fail on purpose and do the three moves. Nothing here is committed, and nothing here reaches GitHub. Four prompts, one at a time.

Prompt 1: Change my home page's headline to the word TEST, and don't commit it. Then, as a second change, make the headline red, and don't commit that either.

Two changes, uncommitted, one on top of the other. Your two deaths.

Prompt 2: That's two tries at a headline. Stop. Tell me, in plain words, what each try changed.

Two lines: the word, then the colour. That is your note.

Prompt 3: Reset to the save point v1-works and throw both changes away.

It may ask permission for a command with "checkout" or "reset" in it. Say yes: nothing was committed, so there is nothing to lose.

Prompt 4: (in a new conversation) I'm at the save point v1-works. What does my home page's headline say?

Your real one, from a conversation that never saw TEST or red.

Prompt 1
Two tries, neither committed. Your two deaths, on purpose.
▼
Prompt 2
The AI names the two tries in plain words. The note you carry.
▼
Prompt 3
Reset done. TEST and red never happened.
▼
Prompt 4
A new conversation reads your real headline. It never saw the tries.

That is the way out of the loop. Next Tuesday, when the second fix fails at eleven at night, you type "stop", "reset to v1-works", and the note into a new conversation, and the third try never happens.

The limit

Two tries is a limit on you, not on the AI¶

One limit. The AI will not stop at two on its own. Starting a third attempt is its default, so the counting is yours, and so is the stop button. Nor does the rule tell you what the cause is: the new conversation finds that, and if it fails too, the pair starts again at v1-works. A bug report is an error message you did not see yourself: read it the same way.

If it didn't work

Common problems¶

It started a third attempt anyway.
That is the tool's default, not your fault. Stop it (every tool has a stop button) and go to step 2. You do not need its summary; you need the reset.
There is no error message, it just doesn't work.
Then what you see is the message. Write down exactly what happens and what you expected instead, in your own words, and take that to step 3. Verified 2026-10-13.
v1-works is from before a change I want to keep.
Reset anyway, and redo that one change afterwards from its own commit message. One thing per commit (level 2) is what makes that cheap.
Something from the attempts is still around.
A setting, a new file, a package it installed. Ask "remove everything that isn't in the save point v1-works", then ask again whether anything remains.
I can't find how to start a new conversation.
Every tool has one: a new chat, a new session, a "clear" command. Closing and reopening the project does it on most platforms. The tool's own name for it is on the words sheet.
The check finds nothing.
Paste the exact message or send a screenshot of what you see; a description loses the part that matters. If this try fails too, that is try one of a new pair: the rule starts again at v1-works.
I don't remember what the two tries were.
Ask the old conversation before you leave it: "in plain words, what did each of the two attempts change?" If it is already gone, the diff from level 2 says what changed since v1-works.
On Lovable and Bolt.new.
"Stop" is the stop button in the chat. The reset is their version history: restore the entry that is v1-works. The new conversation is a new chat on the same project. Not yet tested there.

The words

Each thing on this page, with its three names¶

In the game	Developers say	Plain
one death	`an attempt`	one order and everything the AI did in answer
the death message	`the error message`	what the tool printed when it broke
load the save	`reset to the save point`	back to `v1-works` after two failed tries
a fresh run	`/clear, a new chat`	a new conversation with none of the old tries in it
the death loop	`the loop`	try, try again, worse each time
a guest's complaint	`a bug report`	someone else's "it broke"

Next · Level 5 "A copy you own." Your app and its database, on your own drive.

THE FRAME
Developers say	In the game	Plain
`the developer`	the player	YouYou give the orders and check the work. The controller never changes hands.
`the agent, the assistant`	the character you give orders to	Your AI tool: Lovable, Bolt, Cursor, Claude CodeFast and tireless, and it guesses what you meant. When it guesses wrong, level 4 is the way out.
`the project`	your world	Your app: the folder of files you are buildingNot the chat and not the editor. It can be saved, copied and moved, and every move in this course keeps it safe.
`the platform defaults, rollback`	autosave	The platform’s own undoIt saves when it wants, in one slot with no name, and writes over it. Fine until the day it isn’t.
`process, developers’ habits`	the strategy guide	The five habits in this courseWhat developers do so that losing work stops happening. One per level.

LEVEL 1 · A SAVE POINT
Developers say	In the game	Plain
`a repository, on GitHub`	your save files	A copy of your app on GitHub, under your own accountIt lives outside the platform, so nothing the platform does can write over it. Every commit goes here.
`a commit`	a save	A snapshot of your app: every file as it is at one moment, with a date and a messageThe tool gives each commit a short id like a1b2c3d. Level 2 keeps each one to a single change.
`a tag`	the save’s name	A name you put on a commit, like v1-worksMany commits say “working”. The tag is the one you ask for by name, and still recognise in three weeks.
`“go back to v1-works”`	load	Go back to a commit, by its tag“Go back to v1-works” puts every file back as it was then. It brings back the app, never the data.
`rollback`	autosave	The platform’s undo buttonIts autosave: one slot, no name, written over. Not a commit, and not yours.

LEVEL 2 · READ THE CHANGE
Developers say	In the game	Plain
`the plan`	the placement ghost	The list of files a change will touch, before anything changesAsk for it, read it, then say go. A file you never asked about is the one to ask “why?” about.
`small commits`	one block per save	One change per commitThen “which change broke it” has one answer, and one commit to take out.
`a diff, in plain words`		What changed since a commit, file by fileAsk for it in plain words, with the commit each file came in with. The file name tells you where to look.
`Login.tsx, SignUp.tsx`	a file in the world folder	One page or part of your app, as a fileUsually named after what it does: Login.tsx is the login. A file name on a plan or a diff is the clue.

LEVEL 3 · TRY IT ON A COPY
Developers say	In the game	Plain
`your users`	the guests	The people who use your appThey use what you built, get stuck, and leave if it is broken. Everything you try, you try in front of them, unless there is a preview.
`publishing, going live, deploying`	opening the gates	Sending a change to the live copyOnce it is published, your users see it. The preview comes first.
`a preview, a staging environment`	practice mode, the gates closed	A second copy of your app at its own address, where nothing countsBuilt from its own line of commits, with its own test database. Every change goes here before it is published.
`production`	the gates open	The live copy of your app, the one your users are inWhatever is published here is real. Nothing here is a test.
`an environment variable`	the copy’s world settings	A setting that says which database, email service or payment provider a copy of the app usesOne line like DATABASE_URL, set per copy. It decides where a form’s data went; the green tick does not.
`the database`	the guest book	Where your app keeps what your users typedTables of rows on the platform’s servers. A commit never holds it, so going back to v1-works never touches it.

LEVEL 5 · A COPY YOU OWN
Developers say	In the game	Plain
`the project folder`	the world folder	Your app as a folder of filesOn the platform’s servers it is theirs to keep or lose. In your repository it is yours.
`a private repository you own`	your world on your own drive	A repository under your own GitHub account that only you can seeNot an organisation with the platform’s name on it. Check the owner on github.com, signed in as yourself.
`an export, a backup`	a copy of the guest book on your own drive	The database copied to a file: every table, every rowThe only copy of your users’ data that you hold. Once, to learn what it leaves out, then on a schedule.
`an off-platform backup`	your own drive	Kept somewhere that is not the platform: your own computer or your own cloud driveA backup that lives on the thing it backs up goes down with it.
`code is versioned, data is not`		Going back to a commit brings back your app, never its dataThe one place your app is not like a game save. The export is the answer.