What we take, where it goes, who can see it.

The session transcripts your coding agents already keep on your machine — Claude Code, Codex, opencode, Cursor. Not your repositories, not your shell history, not your environment.

We read through your transcripts and rank them for behavioral signals using a combined arithmetic and LLM approach. Most of it is deterministic arithmetic — rates, latencies, recurrence counts, and correlations computed over each session’s event stream. A language model handles only what arithmetic can’t: classifying genuinely ambiguous turns and recognising the same rule stated two different ways. It sees short redacted excerpts in batches, never whole transcripts, and nothing you upload is ever used to train a model.

These are the signals we mainly look for:

• Correction taxonomy. Every correction you make is sorted into one of four types — additive (the brief was missing context), redirective (the agent misread intent), rejective (a taste mismatch), or undo (damage already landed) — by phrase matching, with only the genuinely ambiguous turns classified by the model.
• Constraint articulation. Detects rule-shaped language (“never”, “always”, “use X not Y”) arriving right after a violation, then counts how often the same constraint recurs across sessions, with the model folding paraphrases of one rule into a single canonical form.
• Approval behavior. Timestamp arithmetic on the plan gate: seconds between a plan being presented and your approval, normalized by plan length, paired with whether you later object to something that was in the plan you approved.
• Session dynamics. Correction and tool-error density across each session’s timeline — whether sessions degrade in the back half, whether you restart or grind through a failing one, and how your prompts change after the first frustration marker.
• Ask structure. Counts the distinct asks in each prompt and joins them against your own “you forgot / you missed” corrections, measuring how often batched requests get dropped.
• Calibration. Correlates when you reach for plan mode or sub-agents against how large the task actually turned out to be, separating calibrated judgment from ritual habit.
• Rhythm. Pure timestamp arithmetic: correction and undo density by hour of the day, and whether replies fired inside thirty seconds run vaguer and get corrected more than your deliberate ones.
• Intent encoding. Measures how resolvable your briefs are: unresolved referents (“this”, “fix it”) with no path or identifier attached, examples read as literal specs, and how much of the brief’s own vocabulary survives into the plan it produces.

We do not store your raw transcripts. Processing extracts what the report needs to show its evidence, and only that extraction is kept:

• Plan artifacts. Plans your agent presented in-session, and the HTML plan documents it produced.
• Your prompts. The instructions you wrote, after credentials and personal paths are scrubbed on your machine — the upload checks its own output and refuses to send anything the scrub missed.
• Select tool results. Kept only where a signal needs them — for example, the error a correction was responding to.

Beyond that: the email address you sign in with. No telemetry, nothing else.

A managed database holds your scores and account; cloud object storage holds the extracted artifacts. Scoring runs as plain arithmetic on our servers, and the excerpts described above are the only material a language model ever sees.

You, behind your sign-in. Reports are private by default. Making a report public shares everything in it with anyone who has the link — including the prompts and plan artifacts its evidence links to. We never sell your data or share it with anyone else.

Delete means delete. Every report page has a delete control. Using it removes the scores, the stored artifacts, and the upload record in the same action — no soft-delete, no retention copy, nothing left to expire.

Redaction has limits. Scrubbing is pattern-based, and a secret shaped like nothing we recognise can get through. If your sessions touch unusual credentials, run prduck scan --dry-run first — it writes what an upload would contain to a local file, sending nothing.

No automatic expiry. Uploads and reports are kept until you delete them. Nothing expires on its own yet.

Extracted text does upload. Some tools analyse transcripts locally and upload only derived numbers. PRDuck uploads the extracted text itself — your prompts and plan artifacts — so your report can show you the evidence behind every score. If that trade isn’t one you want, don’t upload — nothing runs without the command.

Any change to what uploads or what is stored rewrites this page in the same commit. That rule predates the upload path and has held through it. The effective and last-updated dates above move with every such change, so the date is the version.

Related: Methodology describes how the scores themselves are computed.