∵ causari

AI-written code has no author. It has causes. Causari records them.

How many lines from AI-tagged commits are still alive in your repo? One command, any git repo, no setup. A count, not a grade.

causari.dev  ·  Weekly Survival Report  ·  Method  ·  Manifesto  ·  Roadmap  ·  Releases

curl -fsSL https://causari.dev/install.sh | sh     # Linux / macOS (Windows below)

re audit                    # the repo you are in
re audit vercel/next.js     # any public repo, cloned to a temp dir and removed after

$ re audit
∵ causari · AI code survival
───────────────────────────────────────────────────
  216 commits analyzed (git metadata only, no setup required)

Verified AI-tagged: 14 commits, 6267 introduced, 5185 survived
  survival 82.7% line-weighted · 82.7% capped · median 92.8%
Probable AI-assisted: none detected
By agent (verified only)
  agent                commits introduced  survived  line-wt   capped   median
  cursor                    14       6267      5185    82.7%    82.7%    92.8%

Baseline: untagged lines of the same repository
  untagged: 202 commits, 95759 introduced, 76085 survived · 79.5% line-weighted · 92.1% median
    line age                AI-tagged                 untagged
      0-30 d       85.6% (13 commits)      82.7% (142 commits)
     30-90 d                        —       75.8% (23 commits)   (below floor on one side)
    90-180 d         73.9% (1 commit)       62.6% (37 commits)   (below floor on one side)
  age-matched: AI-tagged 85.6% vs untagged 82.7% of the same age → +2.9 points, over 1 window holding 75% of AI-tagged lines

Confidence notes
  · VERIFIED = explicit metadata (trailers, bot author, etc.)
  · PROBABLE = weak heuristic; may include human-assisted commits
  · UNKNOWN commits are excluded from headline numbers; they form
    the untagged baseline (human, inline-completed and untagged-agent code alike)
  · Only lines from AI-tagged commits are measured; inline completions
    (Copilot, Cursor Tab, …) leave no git trace and are invisible here
  · A measurement, not a grade: method v3 at https://causari.dev/method

Everyone argues about how much code AI writes. Nobody can check the numbers. re audit reads plain git history — Co-Authored-By trailers, bot authors, agent markers — finds the commits that carry machine-readable AI authorship, and asks git blame how many of their lines are still at HEAD. No model, no estimate, no survey. Anyone re-runs it and gets the same bytes.

• --json the exact bytes behind any published row
• --summary Markdown for CI; --badge / --card one-colour SVGs
• --save append a snapshot to track your own trend

Compared with what: since method v3 every audit puts the repository's own untagged lines next to the AI-tagged ones, by line age, and states the age-matched gap: AI-tagged survival against untagged survival of the same age in the same repository. It also names the oldest line still at HEAD and how many commits predate it: a repository that was cleared or rewritten shows there, and its ratio is read accordingly.

What it cannot see: code from inline completions (Copilot, Cursor Tab, Windsurf, …) leaves no git trace and counts as human, so it is in the untagged baseline. Commits without a trailer are UNKNOWN. A formatter pass or a moved function counts as a death under method v1. One bulk commit can dominate a line-weighted ratio; ratios under 5 AI-tagged commits are flagged. All of this is written out at causari.dev/method, with how to contest a number. The questions people ask, answered with the command and the limit: causari.dev/faq; how this differs from git blame, vendor dashboards and churn reports: causari.dev/compare.

The weekly Survival Report runs re audit on up to 100 open-source repositories: a hand-picked list plus the most-starred public repositories (at least 100 stars) where GitHub commit search finds at least five commits carrying the same AI authorship metadata, selected every week, the day before the report, by scripts/survival_discover.py under a rule stated on the method page; rows stay alphabetical, and one line in .github/survival-optout.txt removes a repository.

In CI: a count on every pull request

# .github/workflows/causari.yml
on: pull_request
permissions: { contents: read, pull-requests: write }
jobs:
  audit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with: { fetch-depth: 0 }      # the audit reads every commit; shallow clones are wrong
      - uses: croviatrust/causari@v1

The Action downloads the prebuilt Linux binary (a few seconds), runs re audit --summary, writes it to the job summary and posts one sticky comment per PR. No cloud, no account. A live example.

The ledger: from "which commit" to "which prompt"

The audit works on any history. If you also want to know why a line exists — the prompt, the model, the files the agent read — Causari records agent actions as they happen into a local, append-only ledger (.causari/, gitignored), with a snapshot of the tree before and after each one.

re init                       # create .causari/ (added to .gitignore)
re hook claude-code           # record every Claude Code prompt and edit, exactly
re hook cursor                # same for Cursor, via its hooks.json (prompt, edit, model)
re proxy                      # local LLM proxy: prompts, models, tokens, cost
re watch                      # attribute file changes to captured completions

re why    src/auth.ts:42      # which recorded event introduced this line
re trace  src/auth.ts:42      # upstream: events that fed into it through reads/writes
re impact <event-id>          # downstream: what later events depended on it
re lens   src/auth.ts         # the file annotated line by line with its event
re find   "the JWT refactor"  # search prompts, messages, reasoning
re bisect --test "npm test"   # first recorded event that breaks a test
re revert <id>                # restore the pre-state, with a preview of what else you undo
re fork / re sessions / re switch / re log --all / re diff a..b

What each agent actually gives you today

Claims about "any agent" are cheap. This table is derived from the code and is kept current; if a cell is wrong, open an issue.

Two evidence classes, and every output says which one it is:

• Declared (hooks, MCP, re record): the agent stated what it did. Exact prompt and path. If a human edits a file between two hook events, the hook snapshot absorbs that edit into the next agent event — a known limit being fixed in Phase 1.
• Correlated (proxy + watch): the lines you inserted are searched inside completions captured moments before. A score, not a fact. The adversarial harness in examples/real-session/ gives measured numbers: 100 % on a clean write, 50 % after a formatter pass, wrong per-line attribution when two prompts touch one file in the same window.

Everything stays on your machine. re proxy and the hooks store prompts, completions and commands in clear under .causari/ (gitignored); credentials in recognisable formats — sk-… keys, GitHub/GitLab/Slack/npm/PyPI/Hugging Face tokens, AWS and Google keys, bearer values, JWTs, PEM private keys — are replaced by [redacted:<kind>] before writing, and the record says how many. Anything else you paste is kept as typed. Snapshots store every non-ignored file (.env*, node_modules, target, dist, build, .git and a few others are excluded by default). Treat .causari/ as sensitive. What is stored, what is not, and what the tool does and does not defend against: SECURITY.md and docs/threat-model.md.

Receipts you can verify without us