Skip to content
Zevqi
For engineers, and the leaders who ship with AI agents

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
demo output · Zevqi
$ zevqi status
2 lessons waiting from your last Claude Code session
services/billing/invoice.ts +48 -12 ready
lib/ledger/reconcile.ts +21 -3 ready
$ zevqi learn
Q1/3 Why does the retry loop now cap at 5 attempts?
a) To avoid double-charging when the gateway times out
b) To reduce log volume
c) Because the SDK requires it
> a
Correct. 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.

You get: Knowledge risk page: "If someone left"

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.

You get: Weekly decisions, with the reason for each flag

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.

You get: Coverage that only counts current evidence

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.

You get: GitHub Action comment and optional failing check

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.

You get: Review record export, and plain security answers

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.

For engineers

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.
For leaders: CTOs, VPs of Engineering, engineering managers

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.

Reliability

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.

You see it in: Blind spots report
Resilience

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.

You see it in: Single points of knowledge
Speed

Faster onboarding

New hires take the same lessons as everyone else and learn what changed and why, instead of reverse-engineering AI output alone.

You see it in: People and lesson history
Quality

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.

You see it in: Per-file understanding
Confidence

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.

You see it in: Coverage over time
Habit

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.

You see it in: Developer-side streaks, private
Understood share of AI-changed files
Illustrative demo data
Week 141%
Week 363%
Week 687%

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.

  1. 01

    Capture

    A hook notices that an AI agent changed your code and queues the diff. Nothing else to configure.

  2. 02

    Teach

    A background job writes a short lesson in plain English: what changed, why, and what could go wrong.

  3. 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.

  4. 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.

Acme Payments
Demo data
Understood
68%
of AI-changed files
Lessons
142
97 passed
Waiting
11
not reviewed
Blind spots
9
nobody has passed
Blind spots
  • services/billing/invoice.ts
    6 AI changes · last 2h ago
  • infra/terraform/iam.tf
    3 AI changes · last 1d ago
  • services/auth/session.ts
    4 AI changes · last 2d ago
Coverage by area
services/billing5/14 · 36%
infra/terraform3/8 · 38%
services/auth9/12 · 75%
web/components21/24 · 88%
MemberPassedWaitingPass rateActive
Priya N.31191%12m ago
Marcus L.27384%1h ago
Aiko T.24288%3h ago
Dev R.15562%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.

Estimated value per month
$1,620
22 engineering hours recovered
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.

Individual
$0

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)
Get started free
Team
$10 / dev / month, annual

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
Start 30-day free trial
Enterprise
Custom

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
Book a demo

Compare every plan and estimate your cost →

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.