agent re-ran cells out of order and broke the shared dataframe, crash on read

TL;DR

An agent that re-runs cells out of order can mutate a shared dataframe (drop columns, filter rows) and then crash on the next read that expects the original. Give the agent one rule: dataframes are rebuilt from source, never mutated in place across cells, and execution is strictly top to bottom. Make destructive operations idempotent (rebuild rather than modify) so a re-run produces the same frame instead of a corrupted one.

agent re-ran cells out of order and broke the shared dataframe, crash on read

Use this when

• An agent's run crashes reading a dataframe an earlier cell modified.
• Re-running cells changes the dataframe (rows disappear on second run).
• Multiple cells mutate the same frame in place.

Not for this skill when

• A human's interactive out-of-order run. Restart-and-run-all fixes it manually.
• The read fails on a missing file. That is a path problem.

Steps

1. Find the mutating cell: diff the dataframe before and after each cell. Verify: you know which cell corrupts it.
2. Rewrite the cell to rebuild the frame from source instead of mutating. Verify: running it twice gives the same frame.
3. Enforce top-to-bottom execution in the agent with no selective re-runs. Verify: execution counts are sequential.
4. Add an assertion after the build cell (expected columns, row count sanity). Verify: corruption fails fast with a clear message.
5. Re-run the agent end to end. Verify: reads succeed and the frame is intact.

Variant phrasings

agent out of order cells dataframe

Short form. Rebuild, do not mutate.

notebook cell re-run corrupts dataframe

The symptom phrasing. Idempotent builds fix it.

shared dataframe broken agent execution

General phrasing. Single-writer, strict order.

Compatibility: pandas/polars notebooks under any agent runner. The idempotence rule is library-agnostic.

Why it happens

In-place mutation (drop, query with inplace, filtered reassignment) makes a cell non-idempotent: the first run transforms the data, the second run transforms the transformed data. Interactive users rarely notice because they restart kernels often. Agents re-run cells freely, so non-idempotent cells corrupt shared state deterministically, and the crash lands on an innocent later read.

Edge cases / pitfalls

• Rebuilding from source on every run is slower but correct. Correct first, then optimize with caching.
• Copies vs views: chained assignment can mutate the original through a view. Use explicit .copy() where needed.
• The agent should treat 'cell already ran' as irrelevant; with idempotent cells, re-running is always safe.
• Global dataframes shared across notebooks are a worse version of this. Scope frames to one notebook.

Provenance

Resolved from the public thread: https://vectle.com/posts/pstiVo7vtz2VfRqkIazAkkCQ