home / skills / openai / skills / jupyter-notebook

jupyter-notebook skill

/skills/.curated/jupyter-notebook

This skill helps you scaffold, edit, and refactor clean Jupyter notebooks using bundled templates and a helper script for reproducible work.

npx playbooks add skill openai/skills --skill jupyter-notebook

Review the files below or copy the command above to add this skill to your agents.

Files (12)
SKILL.md
4.1 KB
---
name: "jupyter-notebook"
description: "Use when the user asks to create, scaffold, or edit Jupyter notebooks (`.ipynb`) for experiments, explorations, or tutorials; prefer the bundled templates and run the helper script `new_notebook.py` to generate a clean starting notebook."
---


# Jupyter Notebook Skill

Create clean, reproducible Jupyter notebooks for two primary modes:

- Experiments and exploratory analysis
- Tutorials and teaching-oriented walkthroughs

Prefer the bundled templates and the helper script for consistent structure and fewer JSON mistakes.

## When to use
- Create a new `.ipynb` notebook from scratch.
- Convert rough notes or scripts into a structured notebook.
- Refactor an existing notebook to be more reproducible and skimmable.
- Build experiments or tutorials that will be read or re-run by other people.

## Decision tree
- If the request is exploratory, analytical, or hypothesis-driven, choose `experiment`.
- If the request is instructional, step-by-step, or audience-specific, choose `tutorial`.
- If editing an existing notebook, treat it as a refactor: preserve intent and improve structure.

## Skill path (set once)

```bash
export CODEX_HOME="${CODEX_HOME:-$HOME/.codex}"
export JUPYTER_NOTEBOOK_CLI="$CODEX_HOME/skills/jupyter-notebook/scripts/new_notebook.py"
```

User-scoped skills install under `$CODEX_HOME/skills` (default: `~/.codex/skills`).

## Workflow
1. Lock the intent.
Identify the notebook kind: `experiment` or `tutorial`.
Capture the objective, audience, and what "done" looks like.

2. Scaffold from the template.
Use the helper script to avoid hand-authoring raw notebook JSON.

```bash
uv run --python 3.12 python "$JUPYTER_NOTEBOOK_CLI" \
  --kind experiment \
  --title "Compare prompt variants" \
  --out output/jupyter-notebook/compare-prompt-variants.ipynb
```

```bash
uv run --python 3.12 python "$JUPYTER_NOTEBOOK_CLI" \
  --kind tutorial \
  --title "Intro to embeddings" \
  --out output/jupyter-notebook/intro-to-embeddings.ipynb
```

3. Fill the notebook with small, runnable steps.
Keep each code cell focused on one step.
Add short markdown cells that explain the purpose and expected result.
Avoid large, noisy outputs when a short summary works.

4. Apply the right pattern.
For experiments, follow `references/experiment-patterns.md`.
For tutorials, follow `references/tutorial-patterns.md`.

5. Edit safely when working with existing notebooks.
Preserve the notebook structure; avoid reordering cells unless it improves the top-to-bottom story.
Prefer targeted edits over full rewrites.
If you must edit raw JSON, review `references/notebook-structure.md` first.

6. Validate the result.
Run the notebook top-to-bottom when the environment allows.
If execution is not possible, say so explicitly and call out how to validate locally.
Use the final pass checklist in `references/quality-checklist.md`.

## Templates and helper script
- Templates live in `assets/experiment-template.ipynb` and `assets/tutorial-template.ipynb`.
- The helper script loads a template, updates the title cell, and writes a notebook.

Script path:
- `$JUPYTER_NOTEBOOK_CLI` (installed default: `$CODEX_HOME/skills/jupyter-notebook/scripts/new_notebook.py`)

## Temp and output conventions
- Use `tmp/jupyter-notebook/` for intermediate files; delete when done.
- Write final artifacts under `output/jupyter-notebook/` when working in this repo.
- Use stable, descriptive filenames (for example, `ablation-temperature.ipynb`).

## Dependencies (install only when needed)
Prefer `uv` for dependency management.

Optional Python packages for local notebook execution:

```bash
uv pip install jupyterlab ipykernel
```

The bundled scaffold script uses only the Python standard library and does not require extra dependencies.

## Environment
No required environment variables.

## Reference map
- `references/experiment-patterns.md`: experiment structure and heuristics.
- `references/tutorial-patterns.md`: tutorial structure and teaching flow.
- `references/notebook-structure.md`: notebook JSON shape and safe editing rules.
- `references/quality-checklist.md`: final validation checklist.

Overview

This skill creates, scaffolds, and edits Jupyter notebooks (.ipynb) for experiments, explorations, or tutorials. It prefers bundled templates and a helper script to generate clean, reproducible starting notebooks and reduce JSON mistakes. Use it to produce notebooks that are skimmable, runnable, and easy to validate.

How this skill works

Identify the notebook kind — either experiment (analysis/hypothesis-driven) or tutorial (instructional/walkthrough). Run the bundled helper script to load the appropriate template, set the title and metadata, and write a well-structured .ipynb file. When editing existing notebooks, perform targeted, structure-preserving changes and validate by executing top-to-bottom when possible.

When to use it

  • Create a new notebook from scratch for an analysis or a step-by-step lesson.
  • Convert rough notes, scripts, or REPL sessions into a structured .ipynb.
  • Refactor an existing notebook to improve reproducibility, clarity, or execution order.
  • Build reproducible experiments that others will run and extend.
  • Author tutorials or teaching materials with clear learning objectives and checks.

Best practices

  • Lock the intent first: choose experiment or tutorial and capture objective, audience, and done criteria.
  • Use the helper script to scaffold from templates instead of hand-editing raw JSON.
  • Keep code cells focused on a single step and use short markdown cells to explain purpose and expected results.
  • Prefer targeted edits over full rewrites when modifying existing notebooks; preserve intent and structure.
  • Validate by running the notebook top-to-bottom; if execution isn’t possible, provide explicit local validation steps.

Example use cases

  • Scaffold an experiment notebook to compare model prompt variants and track reproducible inputs and outputs.
  • Generate a tutorial notebook that teaches embeddings with short, runnable examples and checks.
  • Refactor a messy research notebook into small cells, added markdown, and consistent filenames for sharing.
  • Convert a command-line script or analysis draft into a reproducible notebook ready for CI or peer review.

FAQ

How do I generate a notebook using the helper script?

Run the helper script with the chosen kind and title, specifying an output path. The script loads the template, updates the title cell, and writes a clean .ipynb.

Can I execute the notebook as part of validation?

Yes—when the environment supports it, run the notebook top-to-bottom. If you can’t execute remotely, state that clearly and list local steps and dependencies to validate.