Trust what landed, not what the chat says

You are three evenings into a long job. The AI is loading records into a new system in batches, and the session dies halfway through one. A usage limit. A flat battery. A laptop lid.

The next evening you scroll up. The last message reads: batch four done, starting batch five.

So you tell it to carry on from batch five. Or, to be safe, you tell it to run batch four again. Both are wrong, in opposite directions. Carrying on skips everything batch four never loaded. Running it again loads a second copy of everything it did.

You find out a week later. A customer asks why the same cushion appears twice. Another asks where the lamp went. You spend an evening deleting duplicates by hand, with no way to tell which copy holds the right stock.

The transcript was not lying. It was describing a plan. The session ended before the plan finished, and a dead chat cannot tell you so.

Resuming is not restarting, not re-running to be safe, not taking the chat's word for where it got to.

The rules

The chat's last words are intentions, not facts. Sessions die mid-turn after announcing work they never did. The announcement was written before the work, and nothing was written after it. Read it as the plan it was.

Check what landed, cheapest first. Your own list of tasks first, if you keep one. Then the files in your folder and the times they were saved. Then the live system itself. If the job lives in code, its history of saved changes comes before all three.

Resume from the last checked step, not the last announced one. The chat tells you where it meant to be. The export tells you where you are. Only one of those is worth building on.

Never re-run the whole job to be safe. On an import, that is how duplicates happen. The same goes for restoring an older copy over the top. Check that nothing newer landed first, or you erase work no later look will bring back. The safe re-run covers only the rows your check proved missing. The copy you take before any bulk change is step one of Change data without breaking it.

Say what you found before you do anything. Two lines. Landed, and missing. Written down, dated, above the first new instruction. If you cannot write them, you are not ready to resume.

Do it now

1. Do not tell the AI to continue. Anything it does next will be built on the plan, not the result.

2. Open the live system and export what it holds now. For a shop, the product export. For a mailing tool, the contact list. For a sheet the AI was filling in, a copy of it as it stands. If the job lives in a code repository, first run git log --oneline -5 in a terminal, inside the project folder. It lists the last five saved changes.

3. Open a new spreadsheet. Paste every code from your master list into column A, with its heading in row 1. Paste every code from the export into column D. Leave column B empty.

4. Count every code, then count the counts:

In B2, then copied down every row of the master list:
=COUNTIF(D:D, A2)

0 means missing. 1 means landed. 2 or more means a duplicate.

The three totals, in column F, never in B or D:
missing:                =COUNTIF(B:B, 0)
landed once:            =COUNTIF(B:B, 1)
landed more than once:  =COUNTIF(B:B, ">1")

5. If you would rather the AI did the comparison, open a fresh chat, attach both files and paste this:

We were cut off partway through a job. Do not continue it.
Treat anything the earlier chat said was done as a plan, not a fact.
Attached: my master list, and an export the live system produced after the cut.
Compare them on the identifying code in each file, such as the SKU.
Give me three totals: missing, landed once, landed more than once.
List every code in the missing and more-than-once groups.
Then write two lines and nothing else:
Landed: <what the export proves>
Missing: <what was planned or announced and is not in the export>

6. Its comparison is a claim too. Search for three of its missing codes in the live system by hand.

7. Write your two lines down, dated, wherever you track the job. Step two turns that place into a proper sheet. Then resume with the missing rows only.

A worked example

Say you run a one-person online homeware shop. Cushions, throws, lamps and ceramics, 1,400 products in all. You are moving them to a new shop platform with an AI, in seven batches of 200, over a week of evenings. On Tuesday the session cut out partway through batch four.

Chat said:       Batch 4 of 7 imported. Starting batch 5
Master list:     products-master, 1,400 rows, SKU in column A
Export:          new shop product export, taken 19:05 Wednesday
Live count:      712 products, on the new shop's own screen
Totals:          landed once 712, missing 688, more than once 0
Spot check:      3 missing SKUs searched on the new shop. None found
Landed:          batches 1 to 3 in full, batch 4 rows 1 to 112
Missing:         88 rows of batch 4, announced as done. Batch 5, announced as started: 0 of 200
Resumed with:    the 88 missing SKUs only, then batch 5. Count after: 1,000

712 and 688 make 1,400, and nothing landed twice. That is the check.

The failure you will hit

The first time the check agrees with the chat, it will feel like a wasted half hour. So the next time you will skip it, and that will be the night the session died between the message and the work.

The quieter version is trusting a count instead of the codes. A live count of 800 can be 780 real products and 20 duplicates, with 20 missing products hiding behind them. The totals match and the shop is wrong. Compare codes, not totals.

Not for you if

You would rather run everything again than spend twenty minutes in a spreadsheet. You will get duplicates, and you will have earned every one of them.

Step two is saving before the cut, so the next interruption costs you a minute instead of an evening. The Vault is the paid library, and Operations is one of its categories.