DEV Community: kohei matsunobu

Eliminating Accidental Submissions in Kaggle Work: The Kaggle CLI, a Confirmation Wrapper, and Measuring on Production Hardware

kohei matsunobu — Sat, 17 Oct 2026 10:56:10 +0000

This article was originally published in Japanese on Zenn.

Introduction

I've been working on Kaggle with help from LLM agents and scripts. Automation makes things easier, but it also nearly caused accidents, like the workflow going all the way to submission without anyone checking.

In this article, I'll cover how to work with notebooks using the Kaggle CLI, a wrapper that always puts a human confirmation step in the loop, and what I learned from the differences between my validation environment and the production environment.

1. Checking notebook status with the Kaggle CLI

Setting up the token

With the newer token method, you put your token in the KAGGLE_API_TOKEN environment variable.

export KAGGLE_API_TOKEN="(your token issued by Kaggle)"

Getting notebook status and output

You can check the status of a notebook running on Kaggle and fetch its output from the CLI.

# Check whether it's running, finished, or failed
kaggle kernels status <username>/<notebook-name>

# Download the output files locally
kaggle kernels output <username>/<notebook-name>

Since you can see the status without opening a browser, it's much easier to handle from scripts and agents.

2. A confirmation wrapper to prevent accidental submissions

I once had an automated batch go all the way to submission without any confirmation. Submissions are often limited in number, and they can't be undone.

So I built a wrapper that splits the path to submission into these steps:

Show which file will be submitted
Confirm with y/N (pressing just Enter means "No")
Run it
Validate the output (whether the file exists, whether the format is correct, etc.)
Only display the submit command and stop there

For the final submission, a human runs the displayed command themselves. This way, even if something breaks somewhere in the automation, a human always takes a look right before submission.

The confirmation part can be written in Python in just a few lines, for example:

def confirm(message: str) -> bool:
    answer = input(f"{message} [y/N]: ").strip().lower()
    return answer == "y"

if not confirm("Run with this file?"):
    raise SystemExit("Aborted")

The key is making "No" the default. Even when it's called from an agent or script with no input, it won't proceed on its own.

3. Measure time-limited workloads on the same hardware as production

When I was doing local validation on a fast GPU, the trends in the results sometimes differed from those on the slower GPU used in production.

When a workload has a time limit, slower hardware alone can cause it to be cut off partway, or change what you can get done within the limit. Just because something "fits in time" on a fast environment doesn't mean it will in production.

I learned that for time-limited workloads, it's important to measure on the same hardware as production.

Summary

Once you set KAGGLE_API_TOKEN, the Kaggle CLI lets you track your notebooks with kernels status and kernels output, no browser needed
Even with automation, always put a human confirmation step right before submission (default to "No", and only display the submit command)
Measure time-limited workloads on the same hardware as production

The more I automate, the more I feel it's important to decide up front "where a human steps in to stop things."

I Stopped Feeding Whole Jupyter Notebooks to LLMs and Cut Tokens by Over 95% (Claude Code / Codex CLI / PowerShell)

kohei matsunobu — Sat, 17 Oct 2026 10:56:09 +0000

This article was originally published in Japanese on Qiita.

Introduction

When I work on Kaggle, I write code in Jupyter notebooks and ask Claude Code or Codex CLI for reviews and advice along the way. The problem: passing a whole notebook to an LLM came to about 30k tokens per notebook, and after asking a few times, the cost added up fast.

In this article, I'll share the tricks I used to save tokens, plus the gotchas I hit when calling these CLIs from Windows PowerShell.

1. Pass only the "code cell diff" of the notebook

An .ipynb file is JSON under the hood, and it's packed with cell outputs (logs and images) and metadata. In most cases, the code is all I actually want the LLM to look at, so I wrote a script that does the following:

Drops outputs and metadata, and extracts only the code cells
Outputs only the diff against the previous version
Replaces long lines over 300 characters with their "length" and a "hash" (all I need to know is whether the content changed)

With this, comparing versions fits in about 1–1.6k tokens (a reduction of over 95%).

Also, long prompt strings inside a notebook make it hard to read, so I create a "reading view" where those strings are split out into separate .txt files. The notebook I actually run stays as a single file, and I pass the reading view to the LLM or for reviews. That's how I keep the two roles separate.

2. Calling Claude Code / Codex CLI as commands from another program

Claude Code

With claude -p, you can ask a single question and get an answer back without opening the interactive UI.

claude -p --max-turns 1 --disallowedTools "Bash,Read,..."

The key is to disallow tools like file reading and pass only the summary you've prepared yourself. Since it won't go off and read files in your repository on its own, token usage stays cheap.

Codex CLI

I installed it with npm.

npm i -g @openai/codex

When logging in through the browser failed, authenticating with a URL and a code worked.

codex login --device-auth

I pass the question via standard input.

echo "Your question here" | codex exec --skip-git-repo-check -

3. Japanese text gets garbled in Windows PowerShell

When I piped a Japanese prompt from PowerShell into the CLI, the text came out garbled (mojibake). Setting the following three to UTF-8 fixes it.

[Console]::InputEncoding  = [System.Text.Encoding]::UTF8
[Console]::OutputEncoding = [System.Text.Encoding]::UTF8
$OutputEncoding           = [System.Text.Encoding]::UTF8

Also, PowerShell doesn't let you chain commands with & the way cmd does; you get an AmpersandNotAllowed error. If you write commands with a cmd mindset, this will trip you up, so watch out.

Summary

Instead of passing the whole notebook, passing only the code cell diff cut tokens by over 95%
With claude -p, disallowing tools and passing only a summary keeps it cheap
If Codex CLI login fails, try codex login --device-auth
When passing Japanese text in PowerShell, set the three encodings to UTF-8

I hope this helps anyone else who's going back and forth between LLMs and notebooks like I am.