EN HR SL
Start Free
For teams shipping with coding agents

Your agent says it’s done. See for yourself.

Claude Code, Cursor and any MCP agent hand their work back on the task itself — every changed screen in every state, every changed API response, field by field. You approve or request changes on each one, and the agent picks up your notes in its next session.

Start free Connect your agent

Free plan available · one MCP URL, one API key · any web stack

app.usedamper.com — bulk invoice export · screenshots
Damper’s screenshot viewer showing a page before and after an agent’s change, with Approve and Request changes buttons
The gap

Agents write code faster than you can check it.

The bottleneck moved. Writing the change takes minutes; finding out whether it’s right still means checking out the branch, clicking through every state and pasting notes back into a chat.

A diff doesn’t show the screen

Six hundred changed lines tell you nothing about how the empty state looks on a phone in dark mode.

Chat forgets your review

Notes pasted into one agent session are gone in the next, and nobody else on the team ever sees them.

“Tests pass” isn’t proof

You want to see the page and the response yourself, not take the agent’s summary on trust.

How it all connects

Your code goes to GitHub. Everything about the work goes to Damper.

Your agent runs next to your code and pushes it to your git host as usual. Damper holds the other half: why the task exists, what “done” has to prove, the evidence the agent brings back, and what you thought of it.

Your machine Your coding agent

Claude Code, Cursor, Codex or any MCP client, working in your repository.

←↑the task, the spec, the rules and what to capturestart_task
→↓screenshots, API examples, progress and the PR linkadd_screenshot
←↑your verdicts and commentslist_review_artifacts
Damper The task, with everything around it
  • The customer requests and votes behind it
  • Spec, project rules and the completion checklist
  • Evidence: every screen state and API response
  • Your verdict on each one
→↓every capture, waiting in Needs you
←↑approve or request changes
Your team You, in the dashboard

PM, designer, founder or engineer. Nothing to check out or run.

↓code, branches and the pull request — never through Damper
Your git host GitHub, GitLab or Bitbucket

Code review and CI stay where they are. The pull request is linked on the task.

↑↓requests and votes come in; release notes go out
Your customers
ask and vote→ the task is ranked by demand→ built, reviewed and shipped→ the changelog tells everyone who asked

Step by step

  1. 01Pick upstart_task
  2. 02Captureadd_screenshot
  3. 03Reviewapprove · request changes
  4. 04Check the APIadd_api_example
  5. 05Fix what you flaggedlist_review_artifacts
  6. 06Ship with a receiptcomplete_task
01 · Pick up

Your agent starts with the task, the rules and what you expect to see.

Starting a task locks it to one agent and returns the spec, the project rules for the files it’s about to touch, and your review evidence policy — which screens to capture, in which themes, viewports and states, and whether API examples are required.

  • The highest-demand task first — ranked by what customers asked for and pay.
  • No surprises at review time — the agent knows up front what proof you’ll ask for.
app.usedamper.com — roadmap
Damper roadmap board with tasks in Planned, In progress and In review columns
02 · Capture

It captures every changed screen, in every state that matters.

As it works, the agent attaches screenshots of each changed page — empty, loading, error, filled — per theme, viewport and locale, with a before image when the page already existed. They land on the task, grouped by page, in the order the agent captured them.

  • Before and after — side by side, so a regression is obvious at a glance.
  • Variants filtered for you — only dark mode, only mobile, only one locale.
  • Images go straight to storage through a one-time upload link, never through the agent’s context window.
app.usedamper.com — bulk invoice export · screenshots
Screenshots tab of a Damper task, captures grouped by page with theme and viewport filters and review status
03 · Review

Review what it looks like, not just the diff.

Tasks waiting for you show up in Needs you on your home screen. Open one and run through every capture: approve it, or request changes with a note — one sentence is enough. Each verdict moves you to the next capture.

  • Run through — every state in order, before and after side by side.
  • One verdict per artifact — approve, request changes with a comment, or reset.
  • Your whole team sees the same review, not just whoever was in the chat.
←→ next capture ⌘↵ send change request
app.usedamper.com — home · needs you
Damper home screen with the Needs you queue listing a task waiting for review
04 · Check the API

API changes, field by field.

For every added or changed endpoint the agent attaches the request, the response and what the endpoint returned before. Damper lists exactly which fields were added, changed or removed, so you never compare two JSON bodies by eye.

  • One example per outcome — the success and each error case of a route side by side.
  • Copy any example as curl and replay it against your own environment.
  • Credential headers are redacted and long bodies trimmed before anything is stored.
app.usedamper.com — bulk invoice export · API changes
API changes tab of a Damper task showing a request, its response and a field-level list of what changed
05 · Fix what you flagged

The agent reads your verdicts and fixes exactly what you flagged.

Your verdicts are stored on the task, not in a chat log. In the next session, the agent lists the task’s artifacts, sees which ones you sent back and why, and redoes only those. A re-sent capture goes back to pending, so you only look at what changed.

  • Works across sessions, machines and agents — the review lives with the task.
  • Nothing to copy and paste — “changes requested” plus your note is the instruction.
06 · Ship with a receipt

Done means proven, with a receipt to show for it.

Completing a task needs evidence for every item on the project checklist, and Damper checks the declared change kinds against what was attached — API changes call for API examples, UI changes for screenshots. The task moves to review with a completion receipt: what shipped, what was verified and what risk remains.

  • Missing evidence is flagged on the task — or blocks completion if you require it.
  • When evidence genuinely doesn’t apply, the agent has to say why, and you see the reason.
  • Ship it and the changelog drafts itself from the tasks that went out.
app.usedamper.com — bulk invoice export · overview
Overview of a Damper task with evidence counts, checklist proof and agent activity
Why not just review the pull request?

Not another code review tool.

Pull request review asks whether the code is right. Damper asks whether the result is — and makes sure the agent hears the answer. Most teams need both, and they work side by side.

Code review on a pull request Product review in Damper
What you look atThe diffThe result: every changed screen in every state, and every changed API response field by field
Who can reviewEngineers who can read the codeAnyone on the team — product, design, the founder — without checking out a branch
What it’s judged againstThe code that was there beforeThe customer request, the spec and your project’s checklist
Where your feedback goesComments someone has to relay back to the agentVerdicts the agent reads itself and fixes in its next session
What “done” meansCI is green and the branch mergedProof for every checklist item, the evidence you require, and a completion receipt
After it shipsThe pull request closesThe customers who asked hear about it in the changelog

Keep your pull requests. The PR is linked on the task, so code review and product review point at each other.

Evidence policy

Decide once what proof you need.

Set it per project and every agent gets the same instructions at the start of every task — including the locale, theme, viewports and states to capture.

OffAgents aren’t asked for this kind of evidence.
SuggestedAgents are asked for it; gaps show up as warnings on the task.
RequiredA task can’t move to review without it, unless the agent explains why it doesn’t apply.
app.usedamper.com — project settings
Review evidence settings in a Damper project: off, suggested or required for API examples and screenshots, plus theme, viewports and states
Connect

Two minutes to connect. Nothing to install in your app.

Damper is a hosted MCP server, a CLI and a plain HTTP API. Use whichever fits how your agent already works.

MCP

MCP server

One URL and one key for Claude Code, Cursor or any MCP client. The agent gets tasks, context and the review tools.

# Claude Code
claude mcp add --transport http damper \
  https://api.usedamper.com/mcp \
  --header "Authorization: Bearer dmp_..."
MCP setup
CLI

CLI upload

Point it at a folder of screenshots — file names become page and state — or a manifest with before images and API examples.

# invoices-list--empty.png → page + state
damper artifacts upload --task 42 \
  --viewport mobile --theme dark \
  ./screenshots
CLI reference
HTTP

HTTP API

Scripts, CI jobs and agents without MCP use the same endpoints with a project API key.

# under /api/agent
POST tasks/:id/artifacts/screenshots
POST tasks/:id/artifacts/api-examples
GET  tasks/:id/artifacts
PUT  artifact-uploads/:token
Routes and limits
Works with Claude Code Cursor Codex any MCP client any CI job

Private by default

Screenshots and API examples are internal to your team and never appear on your public roadmap.

Secrets stay out

Authorization, cookie and API key headers are redacted before an example is stored, and agents are told to capture test data only.

Your code stays in your repo

Damper never clones or reads your repository. It only stores what your agent sends: task updates, PR links, screenshots and API examples.

Your stack, your tools

Damper doesn’t run your app. Capture with Playwright, your test runner or anything that writes a PNG.

Questions

Before you connect your agent

Which agents work with Damper?
Any agent that speaks MCP — Claude Code, Cursor, Codex and others — through the hosted server. Agents and scripts without MCP use the CLI or the HTTP API with the same project key.
How does the agent take the screenshots?
With whatever it already uses to run your app — usually Playwright or your end-to-end test setup. Damper tells the agent which pages, states, themes and viewports to capture, and stores what it sends. The CLI can upload a whole folder in one go.
Do approvals block the task from shipping?
No. Verdicts are notes for the agent and a record for your team; you decide when a task in review is done. What can block is missing evidence: with the policy set to required, an agent can’t move a task to review without the screenshots or API examples it calls for.
What happens when the agent re-sends a screenshot?
The new capture replaces the old one under the same page and state, and its verdict goes back to pending, so your review queue only ever shows what changed.
Is there a limit?
Up to 60 screenshots and 100 API examples per task, 5 MB per image. Screenshots count towards your plan’s storage.
Does this replace GitHub pull requests or code review?
No. Your code, branches, pull requests and CI stay exactly where they are, and code review still happens there. Damper covers the part a diff can’t show — how the change looks and behaves — and links the pull request on the task, so the product review and the code review point at each other.
Does Damper get access to our source code?
No. Damper never clones, reads or indexes your repository, and it has no GitHub access. Your agent works locally and sends Damper only what it chooses to: task progress, commit and PR links, project docs, screenshots and API examples. Screenshots and examples are visible to your team only.
Does Damper do anything besides review?
Yes — review is one stage of a loop. Damper also collects feedback, ranks your roadmap by what customers pay, and announces each release to the people who asked for it.

Stop reviewing your agent’s work in a chat window.

Connect Damper, hand your agent the top task, and check every screen and every response before it ships.

Start free See the whole loop