Done. Proven.
Every ticket shipped.
Tyne reviews every change against the ticket while it's being written — checking security, compliance, and acceptance criteria — then writes the proof back into your system of record.
Validate & Review score
94.2%
Every review returns a score and a risk level, with file-and-line evidence.
Verification point
IDE-time
Verification happens while the file is still open, eliminating PR noise.
The discipline
Proof
81% of leaders report AI-code production issues despite 92% shipping confidence — CloudBees study →
01 // The principles
Three pillars of delivery integrity
01 // Promise & proof
Core standard
Every "Done" has evidence attached.
Findings with evidence
Each security or scope finding carries file-and-line evidence and a suggested fix in the Validate & Review report.
02 // Aligned truth
Core standard
The PM, the dev, and the exec are looking at the exact same number.
One review score
The Validate & Review score and risk level, posted from the VS Code sidebar back to the Jira or Linear ticket.
03 // Timing advantage
Core standard
Verification happens while the developer still has the file open.
IDE-time verification
Operates in your editor, not PR-time — eliminating feedback latency.
02 // What a review checks
Security, compliance, and the ticket — in one pass
Security review
Every diff is screened for the mistakes that reach production quietly.
- Hardcoded secrets — API keys, tokens, credentials — blocked before they enter a commit or git history.
- Data-flow heuristics map changed code from source to sink, flagging unsigned webhooks and risky input paths.
- Deterministic checks run locally, before a single line is sent to a model.
Compliance & governance
Governance moves to commit time, so the audit is a by-product, not an event.
- Pre-commit gates enforce architectural and criteria alignment, and block unverified pushes.
- The Validate & Review report records each finding with its file, line, severity, and a suggested fix.
- BYOK or managed mode — you decide exactly what leaves the machine, and it is redacted before it does.
PM ticket verification
The ticket is the spec. Tyne holds the code to it, line by line.
- Connects your active Jira or Linear ticket and extracts each acceptance criterion into an enforceable rule.
- Every criterion (AC-1…N) is evaluated against the actual modified diff — no PR noise, no false positives.
- Scope drift is isolated: edits unrelated to the ticket are surfaced instead of silently shipped.
03 // Who it is for
Built for every role facing the trust gap
01 // The Risk
"Done" on the board is often unverified fiction.
Tickets get marked complete without evidence. Missing criteria and broken flows only surface during client demos or release calls.
01 // The Tyne Standard
File-and-line evidence attached to every "Done" ticket.
Tyne reviews code against Jira and Linear acceptance criteria at IDE-time, attaching file-and-line evidence and a review score before status changes.
04 // The trust gap
Quantify the cost of unverified AI velocity
Calculate the real operational waste of PR noise, rework, and unverified AI code across your engineering team.
Direct operational savings from automated ticket verification, eliminating unreviewed AI drift, and stopping broken acceptance criteria before merge.
05 // The engine
Anchor, review, and tie the knot — without leaving VS Code
Start a Thread
Pick a Jira or Linear task — or set a Solo goal — and Tyne opens an isolated tyne/<task> branch anchored to it.
Goal-anchored Threads — each session is scoped to one task, with branch isolation so work stays contained.
Drift detection — Tyne watches your edits for changes that wander off the task while you write.
Code in checkpoints
Work as normal and commit checkpoints — "stitches" — as you go. Nothing is analysed until you ask for it.
Stitches — lightweight commit checkpoints that give the review a clean history to reason over.
Project Lead Mode — optional workspace prep, validation reminders, and drift sensitivity you control.
Validate & Review
Run one combined review (Cmd/Ctrl+Shift+T) across scope, code, security, and quality — while the file is still open.
Scope alignment — the diff is checked against the linked task or Solo goal, not just style.
Security + code review — deterministic and AI findings, each with file-and-line evidence and a remediation.
Local graph grounding — 1-hop callers, callees, and LSP references packed locally so breaking changes on outside files are retained.
Score, risk & findings
The report returns a score and a risk level, completed and pending goals, security findings, and missing-test signals.
Score & risk level — a single read on whether the change is ready, not a wall of PR comments.
Quality scorecard — complexity, clones and local quality signals — TypeScript uses the local compiler.
Fix in the editor
Clear findings without leaving VS Code — apply a patch, hand it to your agent, or use Quick Fix.
Fix / Fix in IDE / Quick Fix — apply a verified patch, or send the finding to your agent with a ready prompt.
Ignore / Undo — dismiss noise or reverse an applied patch — you stay in control of the diff.
Tie the Knot
Merge when you accept the residual risk. Tyne can post feedback to the ticket and mark the task done.
Writeback — verified status and comments pushed back onto the Jira or Linear ticket.
Commit synthesis — evidence-aware commit messages, so the git history carries the same context.
06 // Validate & Review
Validate & Review, in action
One command runs scope, security, compliance and quality against the linked ticket — and returns a single report you act on without leaving the editor.
Deterministic pre-screening
Local secret and data-flow scanners catch hardcoded credentials and risky paths before any model is queried.
Scope alignment
Every diff is checked against the linked task; unrelated edits are surfaced as scope drift, not merged into the audit trail.
Writeback to your board
Findings collapse into one score and risk level, posted back to the Jira or Linear ticket.
Run a review to validate this diff against the ticket — scope, security, and quality, in one pass.
07 // In detail
How the review actually works
Lane 01 / security
A local security pass on every change
The security review is deterministic and runs on your machine — it never waits on a model to be online, and nothing leaves the editor until it clears.
- Secret detectionCredential patterns — Stripe, AWS, GitHub, JWTs, private keys — are matched against the diff and blocked pre-commit, so a live key never reaches the bundle or git history.
- Data-flow analysisChanged code is mapped source → transformation → sink using line and hunk heuristics, flagging unsigned webhooks and risky input paths. It is a heuristic, not full-program taint analysis.
- Local-first executionThe deterministic checks — hardcoded-secret scanning and data-flow heuristics — execute locally, before a single line is sent to any model.
- Local graph retrieval & groundingTyne queries a persistent on-device 1-hop import/export graph, 800ms LSP references, and AST fingerprint clones. Findings are grounded on changed files ∪ neighborhood paths — capturing breaking changes in outside callers instead of dropping them.
- Redaction at the boundaryIn managed mode, anything flagged as a secret is redacted before the diff is transmitted — the review sees the shape of the code, not the credential.
08 // Team learnings
Your suppression list is a file in your repo
Every review tool eventually learns what your team has decided to accept. Tyne is the one where that decision is a file — opened in a pull request, blamed to a name, removed with git revert.
One bullet, one decision
When a review raises something your team has already settled, the finding is hidden — for everyone, permanently, without anyone re-teaching it. A reason after the dash is expected; a glob in parentheses narrows it to one part of the tree.
# .tyne/learnings.md — what this team has already decided. - Console.log left in code — workers stream to stdout (src/workers/**) - Unhandled rejection in async handler — the route wrapper catches it - SEC_HARDCODED_KEY — suppress by rule ID instead of by title
What follows from that
| Property | A file in your repo | Learnings in a vendor cloud |
|---|---|---|
| Reviewed before it takes effect | It lands in a pull request | No |
| Attributable | git blame names who, and when | No |
| Inherited by a new clone | Yes, with the repository | Account and org setup |
| Removable without the vendor | git revert | No |
Nothing hides silently
Every suppressed finding is still listed, with the learning that hid it and who put it there. Security and compliance findings are never hidden by a similarity guess — that takes an exact, deliberate decision.
Team learning: “console.log left in code”, scoped to src/workers/**
.tyne/learnings.md:3 · added by Priya on 14 Mar
You dismissed this finding previously.
09 // Integrations
Two-way synchronization
GitHub, Jira, and Linear are live today (Jira and Linear are two-way). Core connects one PM tool; Pro and Max connect both. Roadmap integrations are not yet available.
10 // Pricing model
Metered by review, not by token.
Managed reviews, per month
Managed Validate & Review runs are metered per month — 5 on Core, 50 on Pro, unlimited on Max.
The problem with AI subscriptions
Per-token billing leaves developers watching a meter, afraid a large review will land a surprise bill. Tyne meters whole reviews instead of tokens, so a run costs the same whether the diff is ten lines or two hundred.
Graceful degradation
Reach your monthly managed quota? Your workflow never stops. Add your own Claude or OpenAI key (BYOK) and reviews keep running against your provider account instead of Tyne’s.
Axiom AI — standard path
~80% of operations
Ticket parsing, scope checks, and commit synthesis run on the fast path, so the everyday work stays quick and cheap to serve.
Axiom AI — deep path
Architectural review
Multi-file reviews, scope-drift analysis and architecture impact escalate automatically. You never choose — the engine routes by complexity.
Axiom routing — depth is matched to the change. Simple edits never pay for deep analysis.