since-cutoff

Your coding assistant's training data stops before your dependencies' latest releases, so it can write calls your pinned versions no longer accept. since-cutoff shows where your code uses an API that changed after the model's training cutoff, and writes the short notes your assistant needs to avoid the old form.

The sample project calls client.messages.create and pins anthropic 1.8.0. The latest anthropic release at Claude Sonnet 4.5's training cutoff was 0.60.0, whose create still took temperature; 1.8.0 raises TypeError for it. What scan prints, trimmed to the anthropic part:

$ uvx since-cutoff scan --model anthropic:claude-sonnet-4-5
Your code uses 2 APIs that changed after claude-sonnet-4-5's training cutoff (2025-07-31)

huggingface-hub 0.34.3 -> 2.0.0 (0.34.3 was the latest release at the cutoff; pyproject.toml pins
  2.0.0)
  ...

anthropic 0.60.0 -> 1.8.0 (0.60.0 was the latest release at the cutoff; pyproject.toml pins 1.8.0)
  Messages.create: temperature, top_k and top_p were removed                          uses this API
    app/main.py   calls create
    Note: `Messages.create()` no longer accepts `temperature`, `top_k` or `top_p` as keyword
          arguments. If the API still needs them, pass them through its `extra_body` or
          `extra_query` argument. since-cutoff found no replacement in anthropic's deprecation
          text. [diff]

2 notes ready: `since-cutoff sync` writes them to AGENTS.md and keeps them in step with
  pyproject.toml.

The call in app/main.py passes none of these parameters, so it is marked "uses this API", not "old form": it works today, but an assistant writing for 0.60.0 could add temperature=0.2 when it edits the call. The note is what since-cutoff sync writes into AGENTS.md so that it does not; its tag, [diff], says what the note rests on: a static comparison of the two releases' public APIs. The parameters left the signature, which is not the same as the API dropping the field, so where the pinned method has an extra_body or extra_query argument the note says so instead of telling the assistant to drop the field.

Try it on your project. No API key, no model call. In the project root:

uvx since-cutoff scan

It detects your coding model (or pass --model), reads your lockfile, takes each dependency's latest release on or before the model's training cutoff, and compares that release's public API with the version you pin, statically: no package code runs. The cutoff only chooses which changes to look at; it says nothing about what the model memorised. Whether your model really gets them wrong, and whether the notes help, is what since-cutoff run measures; it calls your model and is optional.

▶ Watch the 2½-minute explainer (video with voice-over)

English | 简体中文 | Español | Français

The problem

Every model has a training cutoff; your lockfile keeps moving. When a library changes its public API after the cutoff, a model whose training data predates the change can keep writing the old calls. Some of that code fails at import or call time. Some still runs, because the old form is only deprecated, or still accepted with a warning.

A few of the changes since-cutoff scan finds for Claude Sonnet 4.5 (training cutoff July 2025) in the sample project, which pins six of its nine dependencies to current releases (for the other three, which are unpinned, the tool uses the latest release):

In that project, 7 of 9 dependencies changed their public API after the cutoff. The static diff flags 310 breaking changes and 23 new deprecations; the project's code uses 2 of the changed APIs.

It is not one model or one vendor. Across 36 widely used Python AI libraries and 21 models from OpenAI, Anthropic, Google, xAI, DeepSeek, Qwen, Moonshot and Mistral, even the newest model tested (Claude Opus 5.5, June 2026 cutoff) predates a public API break in 20 of the 36 (full results):

since-cutoff does three things about it:

1. scan finds, for each dependency, the newest release on or before the model's cutoff, diffs its public API against the version you pin, and shows which of the changed APIs your code uses, where, and a note for each. No model calls, no API key.
2. sync writes those notes into a marked block in AGENTS.md (or CLAUDE.md) after showing you the diff, and keeps them in step with your lockfile; sync --check and status tell CI, pre-commit and your agent when they fall behind. Each note is stated from the API diff and tagged with what was checked. No model calls.
3. run, optional, asks the model short coding tasks that need the changed APIs, with no tools and no docs, and scores each answer with a type checker against both versions: stale, wrong, deprecated or correct. No LLM judges anything. For each failure it writes a note, keeps a model-written note only if its example type-checks against your version, and re-tests the model on held-out tasks without and with the notes.

The same diff is available to agents through an MCP server and to CI through a GitHub Action and pre-commit hooks.

Quick start

# the changed APIs your code uses, with a note for each (no model calls, no API key)
uvx since-cutoff scan

# write those notes into AGENTS.md (shows the diff and asks first); run it again after upgrades
uvx since-cutoff sync

# optional: measure which of the changes your model gets wrong, and test the notes (calls it)
uvx since-cutoff run

Or install it with pipx install since-cutoff (or pip install since-cutoff) and run since-cutoff. Run it from your project root: it reads uv.lock, poetry.lock, pdm.lock, pylock.toml, Pipfile.lock, requirements*.txt, pyproject.toml, Pipfile or a .venv (not setup.py or setup.cfg). Without --model it uses the model your coding agent is set up with, from the Claude Code, Codex, OpenCode or Aider settings; for any other model, pass --model (see Choosing the model). scan, sync and status call no model and need no API key; run sends prompts to the model provider and uses your API credits or Claude Code usage.

What scan prints for the sample project: