trace.See it on a real diff

developer tooling

Your code remembers what. Trace remembers why.

Every line has a reason someone once knew. Trace keeps that reasoning attached to the code — so the next person doesn't have to guess, ask around, or repeat the mistake.

See it on a real diffHow it works →
src/services/userService.ts
+2−2PR #2847
@@ -48 +49 @@fetchUser
4848 const cached = cache.get(id);
49− if (cached) return cached;
49+ if (!isExpired(cached)) return cached;
5150 const user = await db.users...
Why this change

Stale cache entries were returned after TTL expiry — users saw outdated profile data for up to 5 minutes.

#PR 2847↗Issue #1203 — profile staleness

the problem

You found the line.
You found who changed it.
You still can't find why.

Git blame tells you attribution. A name, a commit hash, a timestamp. It answers who and when with precision.

But not why. Not the tradeoff. Not the bug it was hiding. Not the Slack thread that explained the 300-second threshold. That context lived in someone's head — and they left two years ago.

So you make your best guess. You ship it. And in eighteen months, someone else will be staring at your commit wondering the same thing.

auth/session.ts · line 15

auth/session.ts
12 async function validateSession(token: string) {
13 const session = await db.sessions.get(token);
14 if (!session) return null;
15+ if (session.ttl < 300) {
16+ await session.extend(3600);
17 }
18 return session;
19 }
git blame
❯ git blame auth/session.ts
mayaPR #28473 yr ago15
mayaPR #28473 yr ago16
mayaPR #28473 yr ago17
WHO✓
mayaauthor
WHEN✓
3 yr agoPR #2847
WHY?
?no record

the shift

Trace connects the change to the reason.

The reasoning behind a decision rarely disappears — it leaves traces. A commit message. A PR description. An issue thread. A comment in Slack that someone copy-pasted into a ticket.

Trace walks that trail and keeps it attached to the code, so when you land on a line three years later, the context is one step away — not buried in a search tab you'll never find.

Trace doesn't invent explanations. It surfaces the engineering evidence that was already there — commits, PRs, issues, and decisions your team actually made.

auth/session.ts · line 15 · trace

code change

session.ttl < 300

auth/session.ts · line 15

commit

a3f9c1d

Fix session expiry edge case · maya

pull request

PR #2847 · Fix session expiry

Merged 3 years ago · 4 files changed

issue

Issue #1203 · Stale sessions after update

Reported by @dan · Closed by PR #2847

why

Sessions were remaining active past their expiry window. The 300 s threshold triggers a pre-emptive renewal before the token expires, preventing stale auth state on slow connections.

how it works

From change to context.

Trace doesn't invent the reasoning. It connects the engineering evidence that already exists — commits, PRs, issues, and decisions — and keeps it attached to the code that was changed.

1connect

Connect your repository

Point Trace at a GitHub, GitLab, or Bitbucket repository. It reads commit history, pull requests, and linked issues — no agent required.

.trace/config.yml
repo: acme/backend
provider: github
branch: main
connected · 1 repo
2trace

Link changes to their evidence

For every change, Trace walks the surrounding engineering context: commit messages, PR descriptions, referenced issues, and decisions your team recorded.

evidence chain
a3f9c1dFix session expiry
PR #2847Fix session expiry
Issue #1203Stale sessions
3surface

Show the reasoning where the question happens

When you look at a diff, blame view, or PR, Trace shows the connected context inline — without leaving your editor or opening a search tab.

auth/session.tstrace
50+if (isExpired(cached)) cache.invalidate(id);
why

Stale cache entries were returned after TTL expiry — see PR #2847.

The SURFACE step is interactive. Try it on a real diff →

the trace

Ask the line why.

Select a change. Trace follows the evidence back to the decision.

userService.ts:49bug fix
47const cached = cache.get(id);
48−if (cached) return cached;
49+if (cached && !isExpired(cached)) return cached;
50const user = await db.users.findById(id);
why · bug fix

Expired sessions were still being served from cache after TTL. This guard prevents stale authentication state from reaching the client.

PR #2847Issue #1203@maya

Illustrative demo — not real repository data.

where it lives

The answer should be where the question happens.

Trace brings reasoning into the places developers already use to investigate changes — not another dashboard to keep open.

01 · diff
auth/session.ts
47const cached = cache.get(id);
48−if (cached) return cached;
49+if (cached && !isExpired(cached)) return cached;
why · bug fix

Expired sessions were still being served from cache after TTL. This guard prevents stale auth state.

PR #2847Issue #1203
02 · blame
❯ git blame auth/session.ts
mayaPR #28473 yr ago47
mayaPR #28473 yr ago48
mayaPR #28473 yr ago49
whySession expiry was reduced to prevent stale auth state after TTL.

Blame shows who and when. Trace adds why — attached to the same lines, no extra step.

03 · pr review
PR #2847 · Fix session expiry
maya·merged 3 years ago
+if (cached && !isExpired(cached)) return cached;
why · bug fix

This change prevents stale authentication state after TTL expiry.

Issue #1203Stale sessions after update

During review, the decision behind the change is already visible — reviewers don't have to ask why in the comment thread.

Trace doesn't ask you to change how you investigate code. It adds the reasoning to where the investigation already happens.

the point

Your code remembers what. Trace remembers why.

Keep the reasoning attached to the code, so the next person doesn't have to reconstruct it from context, commit messages, and half-remembered conversations.

See it on a real diff change → evidence → reasoning

Trace doesn't invent explanations. It connects the engineering evidence your team already created — commits, PRs, issues, and decisions — and keeps that trail discoverable.