AI writes your code.Does your team understand it?
When AI writes the code, nobody can say who understands which part of it. That is knowledge risk: a departure, an outage or a security review lands on code nobody can explain. Zevqi maps what your team really understands, shows where one person is the only one who knows, and tells you where to spend review time. Every flag comes with its reason, and evidence expires when the code changes, so the numbers stay honest.
- No credit card for the trial
- Source code stays on your machine
- First results in about five minutes
$ zevqi status2 lessons waiting from your last Claude Code sessionservices/billing/invoice.ts +48 -12 readylib/ledger/reconcile.ts +21 -3 ready$ zevqi learnQ1/3 Why does the retry loop now cap at 5 attempts?a) To avoid double-charging when the gateway times outb) To reduce log volumec) Because the SDK requires it> aCorrect. Idempotency keys make the retry safe.
The risk you cannot see today
Comprehension debt: code your team runs but cannot explain
It builds quietly while AI agents ship faster than anyone can read. These are the five ways it shows up, and what Zevqi gives you for each.
One person holds the knowledge
Files that only one person has reviewed. When they leave, go on holiday or get pulled onto something else, nobody can fix or change that code with confidence.
AI changes nobody has reviewed
Agents change a dozen files in a minute. Without a record of who read what, reviews become a glance and the code ships understood by no one.
Knowledge that quietly expires
A review means little once the file has changed again. Evidence here expires when the code changes, so a green number is never stale comfort.
Pull requests with no one who understands them
A change merges because it looks fine, not because anyone could explain it. You see which changed files still have nobody, before the merge.
Nothing to show when someone asks
A security review, a customer questionnaire or a due-diligence call asks who actually reviewed this. You have a record of who, when and their own call.
Source code never leaves your machine, there is no score or ranking for any person, and the free CLI works alone. The team view adds the map, the risk page and the weekly decisions.
Who it is for
Engineers learn it. Leaders lead with it.
The engineer who runs Zevqi learns something every day. The leader who reads it decides something every week.
As an engineer, you learn what your agent just wrote.
Free, open source, and it runs on your machine. No team and no account needed.
- You learn what changed and why. After your agent finishes, a short lesson explains the change in plain language: the decisions in the code, what it depends on and what could break.
- You find out whether you really understand it. Three short questions, then your own call: understood, needs clarification, or investigate. A quick pass is not the same as understanding, so the call is yours.
- You see where you are the only one who knows. The knowledge map shows which files only you have touched, and which AI-changed files nobody has reviewed yet.
- You keep what you learn. Streaks and levels are private to you. Nobody sees a score or a ranking for you.
As a leader, you decide where to spend review time.
See which AI-written code your team has really understood, without reading every pull request.
- You see the gaps. Which AI-changed files have a current review, which only one person understands, and which nobody has, each with the reason it was flagged. Evidence expires when the code changes.
- You decide each week. A short list of files to review and who could review each one, plus a "since last week" summary of what moved. Add a second person to single-owner files before someone goes on leave.
- You gate pull requests. A comment on each pull request names the changed files nobody has understood, and the check can fail until someone has reviewed them.
- You answer the hard questions. Source code never reaches Zevqi, and the security questionnaire answers say plainly what we have not built yet. It is not a tool for grading people.
Tech leads and staff engineers sit in both columns: you take the lessons and you read the map. Nobody is ranked, and there is no score per person.
What you get
Outcomes your team and your leadership can see
Zevqi is not another dashboard to watch. It changes what happens to AI-written code before it is trusted.
Fewer surprises in production
Every AI-changed file nobody has proven they understand is flagged before it ships, so the first person to read the code is not on call at 3am.
No more one-person knowledge
See the files only one engineer understands, then spread them on purpose. A holiday or a resignation stops being a risk.
Faster onboarding
New hires take the same lessons as everyone else and learn what changed and why, instead of reverse-engineering AI output alone.
Reviews that actually mean something
A review is recorded as evidence for one version of a file, in the developer’s own words, and it expires when the code changes. Not a thumbs-up on a 600-line diff.
One number for leadership
Answer "how much of our AI-written code has current review evidence?" with a stated formula and a trend, not a feeling. It measures evidence, never competence.
A team that keeps learning
Each developer gets a private streak and level on their own machine to make understanding a habit. Managers see files and coverage, never a score or ranking for a person.
The movement leads track: coverage rises, blind spots shrink, single-owner files get a second person. Your numbers will differ. The dashboard shows yours.
The gap in agentic coding
Agents ship faster than anyone can read.
Agents now write a large share of the diff. Reviews turn into rubber stamps, and the knowledge of why something works lives nowhere.
Reviews became skims
A 600-line AI diff gets a thumbs-up because nobody has the hours to read it properly.
Ownership evaporates
The person who prompted it may not know how it works, and nobody else was ever involved.
Risk hides in the quiet files
Billing, auth and infrastructure change often, and the first person to look is on-call at 3am.
How it works
From AI diff to proven understanding
Four steps, all automatic after a single setup command.
- 01
Capture
A hook notices that an AI agent changed your code and queues the diff. Nothing else to configure.
- 02
Teach
A background job writes a short lesson in plain English: what changed, why, and what could go wrong.
- 03
Answer
You answer three questions in the terminal or the local dashboard, then say honestly whether you understand it. Teammates can run zevqi review on changes they did not write.
- 04
See
Your team dashboard shows coverage with its formula, out-of-date reviews, open questions and knowledge concentration, each with the reason it was flagged.
Team visibility
See who understands what, before it matters
Quiz results roll up into coverage, blind spots and single points of knowledge. Never source code.
services/billing/invoice.ts6 AI changes · last 2h agoinfra/terraform/iam.tf3 AI changes · last 1d agoservices/auth/session.ts4 AI changes · last 2d ago
services/billing5/14 · 36%infra/terraform3/8 · 38%services/auth9/12 · 75%web/components21/24 · 88%| Member | Passed | Waiting | Pass rate | Active |
|---|---|---|---|---|
| Priya N. | 31 | 1 | 91% | 12m ago |
| Marcus L. | 27 | 3 | 84% | 1h ago |
| Aiko T. | 24 | 2 | 88% | 3h ago |
| Dev R. | 15 | 5 | 62% | 2d ago |
Demo data for an imaginary team. Your dashboard shows your own repositories.
Return on spend
What is understanding worth to your team?
Set your own numbers. Everything below is an estimate you control.
Estimate your return
Move the sliders to match your team. These are your assumptions, not our promises.
- Zevqi Team (12 developers, billed yearly)
- $120/mo
- Estimated net
- +$1,500/mo
- Return on spend
- 13.5x
This does not count the cost of an incident in code nobody understood, or the weeks a new hire needs to get oriented. Both are usually larger.
Capabilities
Built for engineering teams that ship with AI
Lessons from real diffs
When an agent edits your code, Zevqi reads the diff and writes a plain-English explanation of what changed and why it matters. Not a generic tutorial.
Questions that test the change
Three questions per change: why it was written this way, what happens when something goes wrong, and what it depends on. Then the developer says whether they actually understand it, and "not yet" is a valid answer.
Zero friction with your agent
Hooks run in a detached background job. The agent is never blocked, and every hook exits cleanly even if a model call fails.
Evidence that expires
A review counts for one version of a file. When the file changes, or after 90 days, the evidence goes out of date and the file shows up again, with the reason.
Knowledge concentration
Find the files where only one person has current evidence, and the sensitive ones among them, before that person goes on holiday or leaves. Framed as team risk, never as a ranking of people.
Privacy by construction
Only file paths, a content fingerprint, scores and the developer’s own answer sync to the team. Explanations and notes are opt-in. Source code never leaves the developer machine.
Plans for every size
Start alone. Scale to the whole org.
The CLI is free forever. Add the team dashboard when more than one person is shipping with AI.
Solo developers and freelancers
- Git knowledge map: who holds the knowledge of each file. No AI, no key
- Attested reviews: read a change and describe it in your own words
- Unlimited AI-written lessons and quizzes when you add your own model key
- Claude Code hooks: lessons build in the background (with a model key)
Teams of 2 to 50 developers
- Everything in Individual
- Team dashboard: coverage, members, pass rates
- Blind-spot report: AI-changed files nobody has passed
- Single-point-of-knowledge report
50+ engineers, regulated or security-sensitive teams
- Everything in Team
- Security review and completed vendor questionnaire
- Custom contract, DPA and invoicing
- Guided rollout and onboarding for your engineering leads
Security first
Your code never leaves your machine
Built so a security review is a short conversation.
Source code stays local
Code is read on the developer machine. With no model key it goes nowhere. If a developer adds their own key, the diff goes only to the provider they chose, under their own account, and Zevqi says so first. It never reaches us.
Minimal sync
A team record contains a file path, a content fingerprint (a git blob hash, so we can tell when a file changed), a score, the developer’s own answer, a lesson id, a status and timestamps. Summaries and notes are opt-in.
Secrets are hashed
Team keys and dashboard tokens are generated with 192 bits of randomness and stored only as SHA-256 hashes.
Locked-down storage
Team data lives in Postgres with row-level security enabled and no public policies. Only our server can read it.
No telemetry in the CLI
The open-source CLI makes no analytics calls. Network traffic is limited to your model provider and, if you opt in, your team server.
Passwordless sign-in
Owners sign in with a one-time email code that is stored only as a hash, expires in 10 minutes, works once and locks after five wrong guesses. Sessions are signed, httpOnly cookies, and admin actions also check the request origin.
Questions
Straight answers
Does my source code leave my machine?
Never to us. With no model key, nothing is sent anywhere except evidence. If you add your own key so Zevqi can write questions, the diff of the changed files goes to that provider under your own account, and Zevqi tells you so before it installs anything. If you join a team, only file paths, content fingerprints, scores, your own answer (understood or needs clarification), lesson ids and timestamps are synced. The git knowledge map sends file paths, commit counts and pseudonymous author ids. Sharing summaries and notes is an explicit opt-in.
Which AI coding tools does it work with?
Any of them. The git knowledge map and attested reviews read your repository, so they work the same with Claude Code, Cursor, Codex or hand-written code. Claude Code also has hooks that prepare lessons in the background, and any agent that reads AGENTS.md can write the lesson itself (beta). We have verified the Claude Code hooks end to end, not yet live Cursor or Codex.
Who pays for the model calls?
By default nobody, because most of Zevqi uses no model: the git knowledge map, attested reviews, the pull-request gate and lessons written by your own coding agent. If you add your own API key so Zevqi writes the questions, those calls go to your own provider account. Zevqi never proxies requests, so there is no markup and no cap from us, and a typical lesson uses a small fast model and costs a fraction of a cent.
Can developers fake their scores?
Scores are self-reported, and we say so plainly. Zevqi measures engagement and understanding as a signal for your team, not as an exam. Do not use it for performance reviews.
Is it free?
The CLI is free and open source under the MIT licence. The hosted team dashboard is a paid Team plan, billed monthly or yearly through Razorpay and covered by a 30-day refund on your first payment.
What happens if you shut down?
The CLI is open source and works fully offline from the dashboard. Your lessons live in a .zlearn folder in your repository (it keeps the old name so existing installs keep working), so nothing is trapped in our service.
Will this slow my developers down?
It should not, and you can start without changing anyone’s workflow. Run the free zevqi audit on a repository first: it reads git history on your machine and asks nothing of anyone. Next, add the GitHub Action, which puts one comment on pull requests you already review. Only then ask developers to record a review, which is a short attested note about the real diff with no quiz and no model key, and zevqi review --pr does it once per pull request instead of after every agent session.
Can a developer just click through it?
Yes, and we say so plainly: a review here is evidence that someone looked at the current version of a file and said whether they followed it. It is not proof of understanding, and it is not an audit of anyone. What keeps it honest is that "not yet" is an equally easy answer and is tracked, evidence stops counting the moment the file changes or after 90 days, and the dashboard flags files that depend on a single reviewer. Use it to find files nobody has looked at, not to grade people, and do not read a green number as a guarantee against outages.
We already use a pull-request review bot. Why add this?
They answer different questions. A review bot looks at the code and comments on it. Zevqi records whether a person understood the change, and shows which files depend on one person or on nobody. It is not a general AI code reviewer and does not try to be one. It works alongside the bot, and the GitHub Action adds one comment to the same pull request.
See it on your own codebase
Book a 20-minute demo. We will walk through a live team dashboard and answer your security questions.