Every prompt leaves room, and the AI fills that room with choices: a default here, a widened scope there, a step it added because its training data usually has one. The choices condition each other, so the distance from your idea compounds. The code can be perfectly wired and still be a different idea. Its summary will never tell you, because the summary comes from the same understanding that produced the code. So it always sounds exactly like your prompt.
The summary sounded exactly like your prompt. The measurement did not. Code reviewers ask whether the code is okay. Derivein asks whether the code is your idea.
Derivein maps code objects: every function, method, class, constant, and variable becomes its own node, in 26 languages, with no compiler required.
Every connection is recorded with the exact line it happens on and its rank in the caller's sequence, so the map can say that B is the third thing A does.
And nothing is guessed. Where the crawler cannot see a connection, it records a hole and says so on the map.
Every call is one of two moves. An order hands the work onward: you, do the next thing. A take asks for a value and stays put: give me that number. Orders form the storyline of a workflow. Takes attach as consultations, and the story stops at them, which keeps one shared helper from tangling every workflow into a blob. Every object in your codebase belongs to exactly one chain: on a live self-scan, 2082 objects out of 2082 were claimed into 464 workflows, with zero leftovers.
Every node and edge carries independent presence on three planes: what you intended, what is built in the code, and what is actually running, witnessed at runtime.
The gaps between planes are first-class alarms. A planned connection never observed in code. An endpoint called that nothing exposes. And the sharpest one, the shadow edge: a connection observed live that the static crawl never saw.
Drift is where unrequested decisions hide, so Derivein treats it as the highest-value signal on the map.
drag, or click the red edge once the deck is open
Real systems mix languages, and derivein's chains hop boundaries the way real requests do. A Python function calls an HTTP endpoint; the endpoint node is language-neutral; the chain continues straight into the JavaScript handler bound to it. Events work the same way: a publish flows through the topic node into every listener, in any language, across 10 message-broker families.
A traced run paints itself onto the same map: which objects actually executed, in what order. When a run fails, the crash is traced to the exact function that died. That node carries the failure everywhere it appears, everything after it renders as never reached, and an alarm is raised. Drag the playhead.
After an agent works, derivein reconciles the footprint mechanically: what the session was supposed to touch, what actually changed, and what changed unexpectedly. Derivein computes all three columns by watching the run itself.
The truth path is deterministic end to end. Crawl the same repo twice and you get byte-identical chains. No AI, no randomness, no statistics anywhere between your code and the map.
Every fact carries how it is known: parsed from syntax, observed at runtime, matched by name, asserted by a person, or pattern-guessed. Weaker evidence always renders differently than stronger evidence.
And where the crawler cannot see, it says so. An empty spot on the map means not observed, never guessed absent. A mirror that hallucinates is worse than no mirror, so this one is not allowed to.
The connection points the other way here: your AI plugs into derivein. Any agent can pull budgeted context packs built from the deterministic graph: the focus object, what breaks if it changes, the workflows through it, and the declared blind spots. When AI explains a node, it narrates the deterministic slice and nothing else.
A read-only GitHub App. Pick your repos, they are imported, and every push triggers a pull and a recrawl, so the map stays live with your work.
map updatedFor code that never reaches GitHub: a zero-dependency agent crawls a local folder and syncs what it finds to your hosted map. Pairing is a one-time device token, and the sync heals itself after time offline.
Point derivein at a repo and watch the system assemble into a map you can hold in your head. The glance takes a minute, and it is the only way to see the decisions you never made.