cd /news/ai-tools/fiu-a-nose-for-code-you-didn-t-write… · home › topics › ai-tools › article
[ARTICLE · art-171804] src=github.com ↗ pub= topic=ai-tools verified=true sentiment=↑ positive

Fiu – A nose for code you didn't write, via sandboxed code workouts

Fiu, a new developer tool named after the Italian word "fiuto" ("a nose for it"), generates small verified coding exercises called Workouts from a team's own repository so developers can practice understanding code written by AI agents. Fiu offers six Workout kinds — Drill, Kata, Prediction, What-if, Rule check and Diagnosis — run via commands such as `fiu drill <file>` and `fiu predict <file>`, with each answer measured by running code inside an OS sandbox rather than asserted by a model, and a Verified Gate accepting a Workout only when its tests prove the real behavior and every distractor Variant in isolation. The tool positions itself as active learning against the "comprehension debt" created as AI agents write more of the code teams own, contrasting with passive knowledge-graph tools such as Understand-Anything.

key takeaway

Fiu turns repository code into sandbox-verified Workouts (Drill, Kata, Prediction, What-if, Rule check, Diagnosis) that only pass a Verified Gate when tests prove the real behavior and every distractor Variant in isolation, letting developers practice code written by AI agents.

read9 min views6 publishedNov 18, 2026
Fiu – A nose for code you didn't write, via sandboxed code workouts
Image: Michielbdejong (auto-discovered)

A nose for code you never typed.

Fiu comes from fiuto, Italian for "a nose for it": a nose for code you never typed, the knack of knowing code you didn't write.

AI agents write more and more of the code we own. Fiu keeps you fluent in it. It turns real code from your repository into small, Verified exercises (Workouts) that you solve yourself, paying down comprehension debt one Workout at a time.

Workouts support two paths: hands-on code fixes in an editor (Drill, Kata) or mental-model verification straight in the terminal without opening an IDE (** Prediction**, What-if, Rule check, Diagnosis).

Kind Mode You… Start one with
Drill Editor find and fix one realistic bug injected into working code fiu drill <file>[#symbol]
Kata Editor rebuild a removed piece of application logic from a brief fiu kata <file>[#symbol]
Prediction Terminal read a Scenario and predict which of four outcomes the code produces ( --questions N for a Series) fiu predict <file>
What-if Terminal predict how a proposed change would alter system behavior fiu predict <file> --what-if "<change>"
Rule check Terminal a Prediction about a business rule (from your .fiu-rules.md , an Understand-Anything domain graph, or typed): does the code really do what the rule says? fiu predict --rule "<words>"
Diagnosis Terminal read a practice incident and choose which of four Causes explains it fiu diagnose <file>

For Drills and Katas, fiu train copies the code and unit tests into a fresh .fiu/attempts/<id>/<n>/ directory and prints its paths. You read README.md, inspect the unit tests, and edit the code in your preferred editor while fiu train re-runs the tests on every save. If $VISUAL is not set, open the printed .fiu/attempts/... files directly in your editor. If $VISUAL is set, Fiu spawns it detached so fiu train keeps your terminal: use a GUI editor (VISUAL="code") or prefix a terminal editor with your terminal emulator ( VISUAL="kitty vim" or VISUAL="gnome-terminal -- vim"). The original Workout in .fiu/workouts/ stays untouched so you can redo it later or share it with your team.

Every Workout's README opens with Around this code: what the folder and file are for (the folder only, for a Prediction), what uses the code, what it uses, and what changes with it. It never describes the code you are working on itself (turn both off with "context": false in .fiu/config.json). After every Workout, a Debrief shows where the code lives, what it is for, which business flows it belongs to, rules it may enforce, who calls it, its tensions (blast radius, churn, hidden coupling), and which neighbours to practise next.

Every answer is measured by running code inside an OS sandbox, never asserted by the model. The Verified Gate accepts a Workout only when its tests prove the real behavior and every distractor Variant in isolation. If a Drill's buggy lines match your actual source file verbatim, Fiu also flags that the bug may already exist for real once you finish the Attempt.

In Fiu, the Atlas (fiu atlas and fiu map) is the entry point to your codebase. It describes what each folder, file, and key symbol is for. Alongside it, Fiu computes Links directly from imports and git history (Uses, Used by, Changes with).

Tools like Understand-Anything (UA) offer a passive way to learn a codebase. They generate a static knowledge graph of summaries, architectural layers, business flows, and domain rules to read. Passive reading is a helpful starting point, but it neither tests your mental model nor proves that documented rules match the code. Fiu provides active learning through verified Workouts.

Fiu's built-in Atlas is much lighter than Understand-Anything in both information depth and token consumption, so the two are not directly comparable. Fiu works standalone with its own Atlas (fiu atlas build). That built-in Atlas gives you everything needed to orient yourself and pick Workouts at a fraction of the token cost.

However, if your team already uses Understand-Anything for other reasons (.understand-anything/ or .ua/), combining the two tools gives you the best setup to unite both strategies. You get broad passive orientation from Understand-Anything alongside active, sandbox-verified practice from Fiu. Fiu reuses that existing graph with zero flags ("understandAnything": false turns it off):

  • Zero-cost Atlas overlay: Fiu uses current(UA) summaries where its own Atlas has none. Runningfiu atlas build skips those files so you never pay twice for tokens already spent.
  • Tracks along business flows (fiu explore --flow "<name>"): Build multi-step Tracks that follow an end-to-end business flow in execution order instead of a single folder.
  • Measured rule checks (fiu predict --rule and fiu map --flows): Turn business rules—from.fiu-rules.md , Understand-Anything's domain graph, or typed on the CLI—into sandboxed Predictions that measure whether the code follows the rule.

Every Workout in Fiu consists of one code file and one test file using only the language's standard library and built-in test runner. When Fiu extracts a unit of code, it replaces frameworks, third-party libraries, databases, and queues with small inline fakes or parameters. This serves two goals:

  1. Focus on your core logic, not framework trivia: You practise your application's real algorithms and business rules without wrestling with framework boilerplate or external library APIs.
  2. Hermetic, portable verification: Because Workouts never importnode_modules or.venv and need no external services, they run in milliseconds inside the OS sandbox. They also behave identically on every teammate's machine when shared viafiu fetch .

Out of the box, Fiu includes built-in Language Profiles for four languages:

  • TypeScript (.ts ,.mts ,.cts ,.tsx vianode --test with type stripping)
  • JavaScript (.js ,.mjs ,.cjs ,.jsx vianode --test )
  • Python (.py viapython3 -m unittest )
  • Go (.go viago test -json )

Extending Fiu to other languages—such as Rust, Ruby, Java, or C#—requires zero changes to the core engine. A Language Profile is pure configuration data. You can declare a new language under "profiles" in .fiu/config.json (or contribute a built-in profile in src/languages/builtin.ts). Each profile specifies extensions, codeFilename, testFilename, static supportFiles, preflightCmd, testCmd (emitting tap or junit-xml), an optional declarationPattern regex, and sandbox cacheDirs.

npm install && npm run build && npm link

fiu init                     # create .fiu/ and check the sandbox
fiu atlas build              # map what each folder, file, and key symbol does
fiu drill src/queue.ts       # generate a Drill and open it in the runner
fiu train                    # practise any pending Workout, Series, or Track

With Claude Code instead of an API key:

fiu agent install claude     # install the MCP server, subagent skill, and /fiu-* commands

Ask Claude Code for a Workout (or run /fiu-drill src/queue.ts and /fiu-atlas). Claude delegates generation to a low-cost subagent, keeping your main coding session's context window clean.

  • fiu atlas /fiu atlas <file> /fiu atlas search "<goal>" : browse the codebase Atlas, see what a file uses, what uses it, and what changes with it, or find the files behind a goal.
  • fiu explore <dir> /fiu explore --about "<goal>" /fiu explore --flow "<name>" /fiu track : build or continue a multi-step Track across a module, a goal, or a business flow from an Understand-Anything domain graph.
  • fiu quick [--while "<cmd>"] : solve a Workout right away, or while an agent runs or a long build or pipeline finishes.
  • fiu map : inspect comprehension coverage and locate unpractised hotspots.fiu map --flows : the same by business flow, with which business rules the code was checked against, when the repository has an Understand-Anything domain graph.
  • fiu stats : track your Prediction accuracy, confidence calibration, andBlind Spots .
  • fiu share [--atlas] /fiu fetch : share verified Workouts and the Atlas with your team on thefiu/workouts branch without touchingmain .
  • fiu auto on : queue a background Quick Drill from each commit. Optional:--rules turns a commit that changes code where a business rule is pinned or already checked into a rule check;--model <id> uses a cheaper model for background work (every Workout is still Verified).
  • fiu cost : inspect token usage and generation cost.

The binary is fiu. See SPEC.md for the specification, GLOSSARY.md for domain terms, and docs/adr/ for architecture decisions.

Fiu is practised on its own code. This repository carries two branches you can use from any clone, neither of which touches main:

fiu fetch

git fetch origin understand-anything
git restore --source=FETCH_HEAD --worktree -- .ua

The graph is a snapshot: its commit message names the commit it was built from, and summaries of files changed since then may describe older code.

This project was called Fiutsu in v6.0 and Kintsugi up to v5.1. The first time you run fiu it moves your existing state for you (see SPEC.md, §3.1). If you used the Claude Code integration, run fiu agent install claude once to replace it. The fiutsu binary is gone: if you installed with npm link, run npm link again from this repository.

── more in #ai-tools 4 stories · sorted by recency
── more on @fiu 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/fiu-a-nose-for-code-…] indexed:0 read:9min 2026-11-18 · —