auditing-jupyter-execution-order

Audit Jupyter notebooks for execution-order defects and stale state.

2|Updated May 23, 2026
One-click install
npx skills add https://github.com/rocklambros/rcs --skill auditing-jupyter-execution-order
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: auditing-jupyter-execution-order
Source: https://github.com/rocklambros/rcs/tree/main/skills/workflow/auditing-jupyter-execution-order
Command: npx skills add https://github.com/rocklambros/rcs --skill auditing-jupyter-execution-order

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill audits Jupyter notebooks for execution-order mistakes that can make results unreproducible, misleading, or unsafe to share. It helps you catch cells that ran out of order, were edited but not re-run, or silently depend on stale notebook state.

Core Features & Use Cases

  • Run-order validation: Detects non-monotonic execution counts that indicate the kernel executed cells in a different order than the notebook layout.
  • Stale-state detection: Flags unrun cells that downstream cells still reference, helping expose hidden dependence on old bindings.
  • Notebook safety checks: Surfaces errored cells, cleared-output notebooks, and papermill-produced notebooks so you can choose the right review path.
  • Sharing and grading readiness: Ideal before sending a notebook to teammates, committing it, submitting it for class, or turning it into a paper or report.

Quick Start

Ask this Skill to audit the attached Jupyter notebook for out-of-order, unrun, or stale cells and tell you whether it is safe to share.

Frequently Asked Questions about auditing-jupyter-execution-order

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I check a Jupyter notebook for out-of-order execution before sharing?▼

To check Jupyter notebook execution order before sharing, audit the notebook for non-monotonic execution counts and unrun cells with downstream dependencies. This detects stale state and hidden bindings left by out-of-order kernel runs.

What causes a Jupyter notebook to have inconsistent outputs?▼

Inconsistent Jupyter notebook outputs are caused by non-monotonic execution counts, indicating the kernel ran cells in a different order than the notebook layout. Editing cells without re-running them also leaves outputs dependent on stale notebook state.

How do I validate a notebook for reproducibility before grading or committing?▼

To validate notebook reproducibility before grading or committing, audit execution_count monotonicity, flag unrun cells that downstream cells reference, and surface errored cells to expose hidden dependence on old bindings.

Does the notebook audit detect papermill or cleared-output special cases?▼

The notebook audit detects papermill-produced notebooks and cleared-output notebooks, warning you when notebook state suggests these special cases so you can choose the correct review path for reproducibility.

Can I flag unrun cells that downstream cells still reference in a Jupyter notebook?▼

You can flag unrun cells that downstream cells still reference in a Jupyter notebook by auditing for stale-state detection. This exposes hidden dependence on old bindings where downstream outputs rely on unrun or edited cells.

What are the limitations of auditing execution count for notebook reproducibility?▼

Auditing execution count for notebook reproducibility detects non-monotonic runs, errored cells, and papermill special cases, but cannot execute the code itself to verify variable values; it only validates notebook state and run-order consistency.