AI writes the PR. Mint proves it works.
Cursor and Claude can create pull requests fast. Mint checks the part that still slows teams down: whether the change actually works.
It reviews the PR, runs your app, captures video or screenshot proof, and posts the result directly in GitHub.
Built for developers using Claude Code and Cursor.
Mint QA
PassedUpdate checkout flow · qa_user · real browser
Demo Preview
Open full video →
Steps
| # | Action | Evidence |
|---|---|---|
| 1 | Open app | View step-01.pngdrop image in /public/images/ |
| 2 | Fill checkout form | View step-02.pngdrop image in /public/images/ |
| 3 | Verify confirmation | View step-03.pngdrop image in /public/images/ |
Checked
- Checkout form submits
- Order confirmation loads
- Redirect to dashboard
- No console errors
Result
Pass.
Works with
AI made it easier to create PRs. It did not make them easier to trust.
Generated code can look done before it has been verified.
The diff looks reasonable. The PR summary sounds confident. But someone still has to run the app, click through the changed flow, check for regressions, and decide if the code is safe to merge.
More PRs to validate
AI increases output. Review time does not disappear.
Still manual to verify
Someone still has to run the app and confirm the change actually works.
Generated code hides risk
AI-written PRs can look finished before anyone has proved they work.
The bottleneck has moved from writing code to trusting code.
Mint closes the gap.
The same workflow, with the manual verification step removed.
Before Mint
- Claude opens a PR.
- A reviewer reads the diff.
- Someone runs the app.
- Someone clicks through the changed flow.
- Someone asks "did anyone test this?"
- The PR waits.
After Mint
- Claude opens a PR.
- Mint reviews the change.
- Mint runs the app.
- Mint records the proof.
- Mint posts the report in GitHub.
- The reviewer starts with evidence.
Start every review with evidence.
Mint gives reviewers the proof they normally collect manually: what changed, what was tested, what passed, what failed, and a recording of the app flow.
Review the PR
Mint reads the diff and identifies what behavior changed.
Run the app
Mint launches your app in the configured environment.
Test the changed flow
Mint checks the user path the PR is supposed to affect.
Capture proof
Mint records video, screenshots, and step-by-step evidence.
Post the report
Mint comments in GitHub with the result, tested steps, proof, and risk notes.
Reviewers see what actually ran.
Mint posts the full report in GitHub — GIF preview, numbered steps with screenshots, evidence bullets, and risk notes. Everything a reviewer needs before they open the diff.
Mint QA
PassedAI-generated checkout update · #142 · qa_user · real browser
Demo Preview
Open full video →
Steps
| # | Action | Evidence |
|---|---|---|
| 1 | Open app | Viewstep-01.pngdrop image in /public/images/ |
| 2 | Complete payment form | Viewstep-02.pngdrop image in /public/images/ |
| 3 | Submit order | Viewstep-03.pngdrop image in /public/images/ |
| 4 | Verify confirmation | View step-04.pngdrop image in /public/images/ |
Checked
- Checkout page loaded
- Test user completed payment form
- Submit button became enabled
- Order confirmation page loaded
- Dashboard redirect worked
- No visible console errors
Result
Pass.
Artifacts are attached to this workflow run as mint-runs.
Browser recording
A full video of what Mint ran — not a summary, the actual app.
Step-by-step screenshots
Every action is numbered and captured. Reviewers see exactly what was tested.
Risk notes
Mint flags auth-adjacent or sensitive code paths and recommends human review.
Mint does not replace human review. It gives reviewers better evidence before they make the call.
Setup
~5 minutes. Zero new services. Your stack, untouched.
We get the objections. “Setup will be a pain. It won’t handle my app. How is this even secure?” Here’s the short answer to each:
Your runner, your network
Runs in your CI, against your stack
Mint runs inside your own GitHub Actions runner. Mint boots your app the same way `npm run dev` does. No new services for Mint to talk to, no proxies, no agents installed on your machines.
Zero direct DB access
Never connects to your database
Mint creates test users via the scripts you write — same APIs your real signup flow uses. Production data is never touched. Local docker DBs, ephemeral test branches, whatever you already use for CI.
Open source action
You can see every line we run
Our GitHub Action is open source at getmint/action. Pin it to a tag, audit the bundle, fork it if you want. Your repo secrets stay in your repo. Mint never receives them.
- 1
Install the GitHub App on the repo you want tested.
30s - 2
Add your MINT_API_KEY to that repo’s secrets.
1m - 3
Paste the Claude/Cursor setup prompt — it writes mint.yml + workflow + a test-user script for you.
3m - 4
Open a PR. Mint posts proof in the comment.
—
Watch Mint test a PR.
See Mint review a pull request, run the app, capture proof, and post the full report in GitHub.
Demo video coming soon
Full flow from pull request to proof report.
Less manual clicking
Reviewers start with proof instead of opening the app from scratch.
Faster PR review
The tested steps are already documented in GitHub.
More confidence with AI code
Generated changes come with evidence, not just a summary.
Why now
AI coding changed the shape of engineering work.
The hard part used to be producing the code.
Now the hard part is verifying more code, faster, without lowering the bar for quality.
Mint is built for that new workflow.
Built for teams shipping real software with AI.
Mint is for teams that use AI coding tools but still need confidence before merging.
Best fit
- Indie teams with real users
- Founder-led engineering teams
- 2–20 person product teams
- Teams using Cursor or Claude Code
- Teams shipping multiple PRs per week
- Mobile, web app, and SaaS teams
- Teams without a dedicated QA process
Probably not a fit
- Idea-stage projects
- Hobby repos
- Teams that rarely ship
- Teams looking for a free code review bot
- Teams with no production risk
- Teams with heavy enterprise procurement
Common questions
Get started
Stop merging AI-written PRs
without proof.
Mint tests the change, captures evidence, and posts the report before your team merges.