The intake pipeline that closes itself
From “it’s broken” to a merged PR.
A client describes a problem in plain language. AI triages it, a human approves in 
Slack, and 
Claude Code fixes it and opens the pull request — reviewed by a person before anything ships.
No account for your clients. A human approves and merges, every time.
The problem
Client bug reports arrive as chaos.
The fix is often ten minutes. The overhead around it — decoding, chasing details, finding the repo, reproducing — is the whole day.
Vague one-liners with no repro steps, no environment, no screenshot.
Spread across email, WhatsApp, Slack DMs, and phone calls — nothing in one place.
Every report costs a developer a context-switch before a single line is written.
EMAIL“it crashed”
WHATSAPP“the page is weird??”
SLACK DM“the button doesn’t work”
MISSED CALL“can we hop on a quick call?”
One loop, four stages
Intake → Triage → Approve → Fix
“It’s broken” in the morning. A merged fix by lunch — with a human in the loop the whole way.
01 — Intake
Capture the report where the client already is.
Your client’s half of the work is one paragraph and a screenshot. intake.report does the rest.
+Smart follow-ups, as many as it takes. AI asks only what’s missing — the exact things a developer would have emailed to ask — with choices to tap where they fit.
+Context captured automatically. Page URL, browser, viewport, and console logs ride along — no round-trip.
+A reference code on submit. The client walks away with a short tracking code — no account, no password.
02 — Triage
AI turns a complaint into an engineering task.
Every report arrives pre-read. Title, severity, repro steps, and the right repo — before a human opens it.
+Structured output with missing-info flags — if a report can’t be worked yet, it says so instead of guessing.
+Repo routing picks the right GitHub repository using per-repo codebase summaries.
+Product context. The project’s user stories ride along, so a report is read against what the feature is meant to do.
+Duplicates fold in. A bug reported twice joins the one already filed instead of opening a second.
03 — Approve
One Slack tap keeps a human in charge.
Nothing gets fixed without your say-so. Approval is one tap where your team already talks.
+The card updates in place as the bug moves — it never scrolls away.
+A thread under the card is the live progress log: claimed, root cause, tests green, PR up.
+Non-bugs never reach the gate. Questions and feature requests are informational only.
+The right person hears first. A new report goes to the project’s default owner — assigned, and in their Slack DMs.
↓ scroll to watch the card advance
04 — The Cockpit
The native cockpit that drives Claude Code.
Approve a bug in Slack. Watch Claude Code reproduce it, fix it, test it, and open the PR — with the bug’s full context sitting right next to the terminal. Zero browser round-trips.
Context beside the terminal
Description, logs, screenshots, and triage render next to the live session. The end of the browser round-trip.
Take over any time
Claude’s session and yours are the same terminal. Grab any bug and drive the fix by hand.
Atomic claims, always on
Launches on login, drains the backlog approved while your Mac was off, recovers stalled sessions.
Review and merge at the desk
The PR, its checks and CodeRabbit’s findings sit in the bug’s panel. Merge from there once it’s green.
Many bugs at once
Tick several tasks to fix, close, or park them in one go — each closing note drafted for you to edit.
Your terminals, on your iPhone
The intake iPhone app watches and types into the Mac’s sessions straight over your tailnet. No relay in between.
Why it’s different
The last tracker that hands you a backlog.
Everything in the loop
Feature highlights
Beyond the loop
Before the report, and long after the merge.
Around the core loop: more ways for a bug to arrive, a memory of what the product should do, and follow-through once the fix is live.
Intake
More ways in
+Chrome extension. Point at the broken element — its selector, DOM details and a marked-up screenshot ride along.
+A Slack thread. Tag the app and the whole thread, screenshots included, becomes a report.
+Your agents, over MCP. Claude and other agents search the board, file with a screenshot or a log, and report progress.
+Errors nobody reported. Uncaught production exceptions from Laravel Nightwatch file themselves as internal reports.
Context
A memory for the product
+User stories. The why behind each bug — drafted from a paragraph, linked to the reports they explain.
+Protected rules. Behaviour the client signed off on, numbered, with who approved it and every change to its wording.
+Project docs. Generated from the code by an agent — private, for the client, or public.
+Roadmap. Epics and their stories on a timeline, one lane per epic.
Follow-through
After the merge
+Testing checklist. Every resolved fix becomes a test; a tester or a QA agent confirms it on the live app, screenshots attached.
+Notes the client can read. What was fixed, in their language — with the fixed screen in line.
+Board and backlog. List or board, drag a card to move it, park later-phase work on the backlog.
+Work log. Every Claude Code session on a timeline per project, with what its tokens cost.
Control
Automation removes the overhead, not the judgment.
The machine fetches, decodes, routes, reproduces, and drafts. A human approves the work and merges the result — every time.
✓A human taps Do it before any autonomous work starts.
✓A human reviews the diff and merges. The machine never merges itself.
✓A report that asks to break a protected rule the client approved is held — no Do it until the client decides.
✓One honest attempt — no silent auto-retry, no faked fix, no spinning forever.
✓The report row is the single source of truth: open → in progress → in review → merged → resolved.
Questions
The skeptic’s FAQ
Does the AI fix bugs without anyone checking?+
No. Two humans-in-the-loop by design: someone taps Do it in Slack before any autonomous work starts, and someone reviews and merges the pull request before anything ships. intake.report never merges its own code.
What if the AI can’t fix it?+
It makes one honest attempt. If it can’t reproduce the bug, it’s the wrong repo, or it needs more from the client, it stops and says so in Slack — it never fakes a fix or spins forever. A human decides what happens next.
Do my clients need an account?+
Not to report a problem: they open the intake link, describe it, and get a reference code. To follow it later they sign in with an emailed link — a bug is never readable by someone who merely knows the URL.
Can our own AI agents use it?+
Yes. intake.report is an MCP server: an agent can search the board before filing, attach a screenshot or a log, add context later, mark progress, and work through the Testing checklist — each with its own token and role.
Where do the tasks end up?+
As a fully triaged report in your intake.report dashboard, and as a live card in your Slack channel. The report itself is the single source of truth for status.
What languages does it support?+
Client-facing intake and follow-up questions in the client’s language (Czech and English today); engineering tasks are standardized to English for the team.
Do I lose control of my terminal or repos?+
Never. The Cockpit runs on your Mac, works in your local repos, and you can take over any session at any moment — Claude’s session and yours are the same terminal. An iPhone reaches those sessions only over your own tailnet, and only once you approve it on the Mac.
Stop decoding bug reports. Start merging fixes.
Join the waitlist and be first to close the loop — from your client’s first sentence to production.
Alpha access
Already in the alpha? Log in.
Sign in to your workspace to manage projects, intake links, and the Cockpit. We’ll email you a magic sign-in link — no password.