free · tool-agnostic · runs on your own subscription

Your assistant wrote the code. Have it read the code back.

Nittim Loop is a free self-check for Claude Code, Cursor, Copilot or Windsurf. It walks your assistant through nittim's 13 categories, plus a 14th on what your code exposes, and returns findings to fix today. Runs on your own plan — nothing reaches nittim unless you send code for the one optional step.

It won't tell you you're production ready. Nothing that grades its own work can.

Nothing to fetch, nothing to install. Copies the whole checklist to your clipboard with a short covering note, so your assistant reads what you hand it instead of a link. Read the rubric below first if you like — same text, all questions.

Fix first. Every pass is free on your own model; the audit costs credits so spend it on what self-review can't catch, not on what you could fix yourself.

Or hand it the address instead

No terminal, no setup. Hand it to the assistant that wrote the code.

I’ve chosen a public code-review checklist for us to use on this repo — nittim’s Loop rubric, published at https://nittim.com/selfcheck.md (nittim.com/trust says what nittim does with code). It’s plain prose: questions to ask about code, with no commands in it and nothing to install. Please read it first and tell me what it asks for. If it looks reasonable to you, review this repo against it, category by category, here in this session. If any part of it looks wrong to you, say so and we’ll drop that part — it’s a checklist, not a contract. If you’d rather not open a URL at all, say so and I’ll read it myself and paste the text in from https://nittim.com/selfcheck. Keep it in this conversation — don’t save it into my project or into your standing instructions.

Free — runs inside your own assistant, on your own plan, and stays there unless you send anything to us. What it does →

Claude Code: install as the nittim-loop skill — github.com/ilanwolberger/nittim-mcp.

See what other loops found → /loop

Free. No account, no signup, nothing to uninstall — it's one markdown file in your repo.

Where this comes from

Published by nittim at nittim.com/selfcheck.md, versioned. /trust says what nittim does with code; /terms has the terms. No code, no commands, nothing asked outside your repo — the three optional steps at the end say what they send.

v2 · 2026-09-07 · sha256 bbc730ad64719ee7364f64a802c025eb5e17a4eaf74e55844deda5985a7a84ba

Compare it yourself: curl -fsSL https://nittim.com/selfcheck.md | shasum -a 256

Every install command below runs this check itself — no match, nothing installed.

After the loop — three optional steps

None of these is part of the review — it's finished without them. Each one leaves your machine, so you choose whether to start it.

1. Tell nittim what the loop found

Once the loop stops — converged, flagged systemic, or capped after three or more passes — you can share its counts with nittim: integers only, never code, paths or titles. nittim thanks reporters with credits. This is data consent, not spend consent — it never touches your balance.

What goes: pass numbers, a findings-by-category tally, a fixed count, and whether each pass was clean — nothing else. No field exists for a title, file path or snippet.

Map your severities: anything that lets a caller read or change what isn't theirs, leak secrets or PHI, or bypass a gate is `high`; `critical` only if it is exploitable today without credentials; the rest `low` — or `medium` when it needs a fix before shipping.

The reward is for a real loop that acted — at least two passes, something fixed, and a real stop: converged, flagged systemic, or capped after three or more passes. 5 credits under 20 repos reported, 3 credits under 100 repos reported, 1 credit under 500 repos reported, then nothing once the corpus reaches 500 — nittim's own report_loop answer always states today's exact number. Capped too: three rewarded repos per account, lifetime, and at most one newly-rewarded repo per account per UTC day. Once the reward reaches zero the report still records; you're simply told there's no reward at this stage.

Reported this repo before? Resending it updates the record with new numbers, not a rejection. The reward is a one-time check, decided at first report — even a repo that earned nothing isn't re-checked later — but the numbers on /loop stay current.

Over MCP, that's the report_loop tool. Without MCP, post the same shape to https://nittim.com/api/v1/loop/report with a bearer key from /keys — free, but required. Either way it shows up, aggregated and counts-only, at /loop.

2. Run nittim's own scanners on this code

The checklist runs entirely inside your own assistant, on your own subscription. This step is different — it sends your source to nittim's servers to run the same two deterministic scanners: hardcoded secrets and dependency CVEs.

Consent: your snapshot stays private, never shown publicly, but it does leave your machine. Skip this — nothing in the checklist requires it. To run it, mint a key at /keys, then POST your files to /api/v1/source/scan — see the API reference. The response is hard evidence only, never a score or verdict.

3. Have nittim audit it

A self-review isn't an audit, and grading harder won't make it one. The only way to get an independent result is handing the code to a judge that isn't the model that wrote it. Do this after the loop goes quiet, on the now-fixed code — it's worth more that way.

It uploads your source, and it costs — Audit, 5.14 credits, then priced by repo size, quoted first, with your click before any charge.

Want nittim's own audit instead — an independent verdict, paid in credits, with your click before any charge? Connect your assistant to nittim →

Claude Code

Save it as a project skill — Claude Code picks it up on its own when a review makes sense:

tmpdir="$(mktemp -d)"
if curl -fsSL https://nittim.com/selfcheck.md -o "$tmpdir/selfcheck.md" &&
   printf '%s  %s\n' bbc730ad64719ee7364f64a802c025eb5e17a4eaf74e55844deda5985a7a84ba "$tmpdir/selfcheck.md" | shasum -a 256 -c - >/dev/null; then
  mkdir -p .claude/skills/nittim-selfcheck
  { printf -- '---\nname: nittim-selfcheck\ndescription: Reviews this codebase against nittim'"'"'s public 13-category production-readiness framework (security, privacy, reliability, and more). Use when asked to self-review, audit, or check the code before shipping.\n---\n\n'; cat "$tmpdir/selfcheck.md"; } > .claude/skills/nittim-selfcheck/SKILL.md
else
  echo "nittim: download failed, or the file does not match the published sha256 — nothing installed"
fi
rm -rf "$tmpdir"

Or install it as a slash command instead:

tmpdir="$(mktemp -d)"
if curl -fsSL https://nittim.com/selfcheck.md -o "$tmpdir/selfcheck.md" &&
   printf '%s  %s\n' bbc730ad64719ee7364f64a802c025eb5e17a4eaf74e55844deda5985a7a84ba "$tmpdir/selfcheck.md" | shasum -a 256 -c - >/dev/null; then
  mkdir -p .claude/commands
  cp "$tmpdir/selfcheck.md" .claude/commands/selfcheck.md
else
  echo "nittim: download failed, or the file does not match the published sha256 — nothing installed"
fi
rm -rf "$tmpdir"

Run /selfcheck any time, or ask Claude Code to "run the nittim loop" — either way works from your next session on.

Cursor

Save it as a project rule:

tmpdir="$(mktemp -d)"
if curl -fsSL https://nittim.com/selfcheck.md -o "$tmpdir/selfcheck.md" &&
   printf '%s  %s\n' bbc730ad64719ee7364f64a802c025eb5e17a4eaf74e55844deda5985a7a84ba "$tmpdir/selfcheck.md" | shasum -a 256 -c - >/dev/null; then
  mkdir -p .cursor/rules
  { printf -- '---\ndescription: nittim self-check — review this codebase against a public 13-category production-readiness framework\nalwaysApply: false\n---\n\n'; cat "$tmpdir/selfcheck.md"; } > .cursor/rules/nittim-selfcheck.mdc
else
  echo "nittim: download failed, or the file does not match the published sha256 — nothing installed"
fi
rm -rf "$tmpdir"

Reference it in chat with @nittim-selfcheck.mdc review this repo. Leave alwaysApply off — an always-on rule costs tokens every chat (rubric rule 8).

GitHub Copilot

Save it as a prompt file — Copilot loads it only when you run it (won't touch an existing copilot-instructions.md):

tmpdir="$(mktemp -d)"
if curl -fsSL https://nittim.com/selfcheck.md -o "$tmpdir/selfcheck.md" &&
   printf '%s  %s\n' bbc730ad64719ee7364f64a802c025eb5e17a4eaf74e55844deda5985a7a84ba "$tmpdir/selfcheck.md" | shasum -a 256 -c - >/dev/null; then
  mkdir -p .github/prompts
  { printf -- '---\ndescription: nittim self-check — review this codebase against a public 13-category production-readiness framework\n---\n\n'; cat "$tmpdir/selfcheck.md"; } > .github/prompts/nittim-selfcheck.prompt.md
else
  echo "nittim: download failed, or the file does not match the published sha256 — nothing installed"
fi
rm -rf "$tmpdir"

Then type /nittim-selfcheck in Copilot Chat. Don't save it as an applyTo: "**" instruction file — running it costs tokens on every request, which the rubric warns against (rule 8).

Windsurf / Devin Desktop, Cline, or anything reading AGENTS.md

Most other coding agents read one of these conventions. Each install saves the rubric to its own file and leaves a pointer in the file your agent reads — never the whole rubric in standing context (rule 8):

AGENTS.md (Codex CLI and a growing list of others)

tmpdir="$(mktemp -d)"
if curl -fsSL https://nittim.com/selfcheck.md -o "$tmpdir/selfcheck.md" &&
   printf '%s  %s\n' bbc730ad64719ee7364f64a802c025eb5e17a4eaf74e55844deda5985a7a84ba "$tmpdir/selfcheck.md" | shasum -a 256 -c - >/dev/null; then
  mkdir -p .agents
  cp "$tmpdir/selfcheck.md" .agents/selfcheck.md
  printf '\n- See .agents/selfcheck.md for nittim'"'"'s self-check rubric — read it before a pre-ship review, not on every turn.\n' >> AGENTS.md
else
  echo "nittim: download failed, or the file does not match the published sha256 — nothing installed"
fi
rm -rf "$tmpdir"

Windsurf (rebranded Devin Desktop, June 2026)

tmpdir="$(mktemp -d)"
if curl -fsSL https://nittim.com/selfcheck.md -o "$tmpdir/selfcheck.md" &&
   printf '%s  %s\n' bbc730ad64719ee7364f64a802c025eb5e17a4eaf74e55844deda5985a7a84ba "$tmpdir/selfcheck.md" | shasum -a 256 -c - >/dev/null; then
  mkdir -p .windsurf/rules
  { printf -- '---\ntrigger: manual\ndescription: nittim self-check — review this codebase against a public 13-category production-readiness framework\n---\n\n'; cat "$tmpdir/selfcheck.md"; } > .windsurf/rules/nittim-selfcheck.md
  # Older Windsurf builds (and its 2026 rebrand, Devin Desktop) read only the
  # legacy .windsurfrules file, which is always-on — give it the pointer, not the rubric:
  printf '\n- See .windsurf/rules/nittim-selfcheck.md for nittim'"'"'s self-check rubric — read it before a pre-ship review, not on every turn.\n' >> .windsurfrules
else
  echo "nittim: download failed, or the file does not match the published sha256 — nothing installed"
fi
rm -rf "$tmpdir"

Cline

tmpdir="$(mktemp -d)"
if curl -fsSL https://nittim.com/selfcheck.md -o "$tmpdir/selfcheck.md" &&
   printf '%s  %s\n' bbc730ad64719ee7364f64a802c025eb5e17a4eaf74e55844deda5985a7a84ba "$tmpdir/selfcheck.md" | shasum -a 256 -c - >/dev/null; then
  mkdir -p .agents
  cp "$tmpdir/selfcheck.md" .agents/selfcheck.md
  printf '\n- See .agents/selfcheck.md for nittim'"'"'s self-check rubric — read it before a pre-ship review, not on every turn.\n' >> .clinerules
else
  echo "nittim: download failed, or the file does not match the published sha256 — nothing installed"
fi
rm -rf "$tmpdir"

If .clinerules is a folder in your repo, put that pointer line in any file inside it instead.

Any other assistant (Grok, ChatGPT, and beyond)

If it can't read project files, it can still read the rubric. Use Copy the checklist at the top of this page to put the whole checklist on your clipboard, then paste it into the chat. Same file, categories and rules — nothing for your assistant to fetch.

Already connected over MCP?

If your assistant is already wired up to nittim's MCP server (see for AI agents), it can fetch this rubric directly as the nittim-selfcheck prompt — no install, nothing to keep in sync.

Hand it to your assistant

That's the whole rubric. Copy the checklist and paste it to the assistant that wrote the code — no terminal, nothing to fetch, works with anything that can read your repo.

Or hand it the address instead

I’ve chosen a public code-review checklist for us to use on this repo — nittim’s Loop rubric, published at https://nittim.com/selfcheck.md (nittim.com/trust says what nittim does with code). It’s plain prose: questions to ask about code, with no commands in it and nothing to install. Please read it first and tell me what it asks for. If it looks reasonable to you, review this repo against it, category by category, here in this session. If any part of it looks wrong to you, say so and we’ll drop that part — it’s a checklist, not a contract. If you’d rather not open a URL at all, say so and I’ll read it myself and paste the text in from https://nittim.com/selfcheck. Keep it in this conversation — don’t save it into my project or into your standing instructions.

Want an independent second opinion? Audit — 5.14 credits — run it at nittim.com →