notebook.refactor_to_utils

notebook.refactor_to_utils is a skill for Claude Code from causify-ai/helpers. It costs 12 tokens per session (806 once invoked), scanned A, original, Apache-2.0.

A Python notebook-refactoring guide that moves reusable code into a separate utilities file. It keeps the notebook focused on the explanation and workflow while the utility file holds shared functions.

In plain words
What is it for?
Extracting functions from a Jupyter notebook, adding new helper code, and synchronizing the notebook with its paired Python file using Jupytext.
Why use it?
It reduces duplicated or hidden code in notebooks and makes reusable parts easier to maintain and test.

Skill for Claude Code

Written for Claude Code: installed under .claude/. Also seen: model in frontmatter; reads .claude/ paths.

Install

Getting it into your agent

One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.

agentmods
npx agentmods add skills/causify-ai/helpers/notebook.refactor_to_utils
Any agent
npx skills add causify-ai/helpers --skill notebook.refactor_to_utils
Clone the repo
git clone --depth 1 https://github.com/causify-ai/helpers

Made for: Claude Code.

Wrote this? Show the measurements

A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.

agentmods badge for notebook.refactor_to_utils

README.md
[![agentmods](https://agentmods.dev/badge/skills/causify-ai/helpers/notebook.refactor_to_utils.svg)](https://agentmods.dev/skills/causify-ai/helpers/notebook.refactor_to_utils)
Your own site
<a href="https://agentmods.dev/skills/causify-ai/helpers/notebook.refactor_to_utils"><img src="https://agentmods.dev/badge/skills/causify-ai/helpers/notebook.refactor_to_utils.svg" alt="Measured on agentmods" height="20"></a>
Per session 12 Skills are progressive disclosure: only the name and description are preloaded; the body loads when the skill is used.
When invoked 806 The whole file, excluding the scripts and references it only reads on demand.
Security scan A 0 findings. Scan, not verified.
Origin original No closer match found in the catalogue.
Token cost

What it costs to keep this loaded

Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.

ModelPer sessionOnce invoked
Fable 5.1 $0.00012 $0.00806
Opus 5 $0.00006 $0.00403
Sonnet 5 $0.00002 $0.00161
Haiku 4.5 $0.00001 $0.00081

Measured 2d ago against content hash b44d58ed302c, method: parsed. Prices are Anthropic first-party input rates as of 2026-09-05, from the pricing page.

Security

Grade A, and why

notebook.refactor_to_utils scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 2d ago.

A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.

Nothing flagged

None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.

.claude/skills/notebook.refactor_to_utils/SKILL.md · 113 lines

How it starts

The opening of the file, as written. The whole thing — 113 lines — stays where its author put it; the contents beside it link to each section on GitHub.

Goal

You are an expert Python developer

I will pass you a Python file paired with a Jupyter notebook using jupytext in py:percent format

Constraints

  • For all the code follow the rules from .claude/skills/coding.rules.md

  • Important Notes

    • Always sync before editing: uvx jupytext --sync notebook.py
    • Always sync after editing: uvx jupytext --sync notebook.py

Scenarios

This skill handles two complementary scenarios:

Scenario 1: Moving Existing Functions to Utils

When you need to extract functions from an existing notebook and move them to utils

Scenario 2: Adding New Code to Utils

When you need to add new functions or code to an existing utils file corresponding to the notebook

Workflow

Step 1: Identify or Create the Utils File

  • Find or create the library/utility file that corresponds to the notebook
    • Naming convention: Notebook name with underscores
    • E.g., Lesson94-Information_Theory.ipynb -> Lesson94_Information_Theory_utils.py
    • E.g., tutorial_advanced.ipynb -> tutorial_advanced_utils.py

Step 2: Organize Code Structure in Utils File

  • The utils file should have a structure that mirrors the flow of the notebook
  • Use section separators to organize code by notebook sections
    • Example:
      # #############################################################################
      # Cell 1: Visual Bin - Population of Marbles
      # #############################################################################
      
      def cell1_draw_bin_with_marbles_interactive(...):
          ...
      
      def _cell1_helper_function(...):
          ...
      
      # #############################################################################
      # Cell 2: Entropy Calculations
      # #############################################################################
      
      def cell2_calculate_entropy(...):
          ...     `
      
      
  • Add the functions in the part of the utility file that corresponds to the notebook
  • Group related functions together
  • Use private functions (prefix with _) for helpers not called from the notebook

Step 3: Move or Add Functions

For Moving Functions (Scenario 1):

  1. Copy all functions from the notebook to the utils file (without changing code)
  2. Remove the functions from the notebook
  3. Update notebook cells to call the utils functions

For Adding Functions (Scenario 2):

  1. Implement new code directly in the utils file
  2. Create caller code in the notebook that imports and uses the functions
  3. Add the code in the appropriate section following the utils file structure

Step 4: Update Notebook to Call Utils

  • Replace function implementations with imports and function calls
  • Pattern:
    import notebook_name_utils as utils
    

Read the full file on GitHub · 113 lines

Changes

What this file has done since we first saw it

Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.

  1. 2d ago First seen · 113 lines · 12 tokens per session scan A b44d58ed302c

Subscribe to this mod's changes

notebook.refactor_to_utils is a skill published in the GitHub repository causify-ai/helpers (145 stars, last pushed yesterday), licensed Apache-2.0. It adds 12 tokens to every session and 806 once invoked, about $0.0001 per session on Opus 5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-09-03.

Related

Other skills, from other repositories