Upon visiting the Directory Browser in GitClear, you can drill down to individual file blame views by choosing a file within the browser:
linkWhat this view answers
Traditional git blame answers one narrow question: which commit last touched this line? The Blame view revisited answers the two questions developers actually ask when they open an unfamiliar file:
Who changed this line? The human author, and the LLM that authored it, named by model (e.g. "Opus 5.0", "ChatGPT 5.6").
Why was it changed? A per-line explanation of the intent behind the change, not just a commit subject shared across dozens of unrelated lines.
Each row carries the line's original age (when the line was first introduced), its last change (when it was most recently touched), the last author, the explanation, and the AI attribution. A color band on the left encodes line age at a glance, so the freshly-churned regions of a file separate visually from the parts that have been stable for months.
linkMoving backward through history
The Previous arrow on each row is the core interaction. Clicking it steps that line back to its prior revision — showing what the line used to say, who changed it at that point, and why. Repeat the step to walk a single line all the way back to its introduction, without leaving the file or reconstructing the sequence from a list of commits.
This turns blame from a snapshot into a timeline. Instead of "this line was last touched by commit 33e6ce67," you get the full chain of decisions that produced the line in front of you.
linkHow LLM attribution is derived
Two paths, at different levels of granularity:
AI Telemetry packages (highest granularity). Installing GitClear's telemetry — in the same spirit as OpenTelemetry — captures which agent authored which code as it is written, so attribution is resolved per line rather than inferred. Supported across Claude Code, Cursor, and Codex. Install Pinpoint AI Telemetry works on GitClear SaaS or Diff Digest
LLM API integrations (lower granularity). Where telemetry isn't installed, GitClear connects directly to the AI vendors' usage APIs — GitHub Copilot, Cursor, Anthropic Claude Code, Augment, Gemini, Codex — to attribute AI involvement from usage data. Coverage is broader, resolution is coarser. Set up AI usage metrics
Lines with no AI signal are shown as ---, so human-authored code is distinguishable from unknown-provenance code rather than silently lumped together.
linkWhy "revisited" and not just "blame"
Two capabilities separate this from every other blame view:
It instruments LLM authorship per line. Conventional blame was designed when the only possible author was a person. When a substantial share of a file is written by agents, "last author: Sarah Kim" is at best half the answer — she may have accepted, reviewed, or prompted the change rather than typed it. Naming the model alongside the developer restores the missing half. No other blame implementation records this, because it requires capturing authorship at write time rather than reconstructing it from the commit graph.
It follows lines through moves and partial edits. Standard blame breaks in the two cases that matter most in real codebases:
Moved code. Extract a function into a new file and blame attributes every line to the developer who moved it, on the day they moved it. The real history is erased. This view tracks lines across file boundaries, so the "original age" column keeps reporting when the logic was actually written.
Partially updated lines. Rename a variable or reformat an argument list and standard blame resets the entire line to the reformatting commit. This view distinguishes a line that was substantively rewritten from one that was incidentally touched, preserving the meaningful history underneath cosmetic churn.
The combined effect: a blame view where a 24-day-old line reads as 24 days old regardless of how many files it has lived in or how many times it has been reindented — and where the answer to "who wrote this?" includes the agent that actually did.