Nitpicks… now with issue numbers. Small gripes, properly filed. Petty? Maybe. Tracked? Always. It bugs them. Now it's a bug. From “ugh” to issue #412. It bugs them. Now it bugs you. They have notes. Numbered ones. Works for you? #412 disagrees. Point at it. Your agent takes it from there. Say what's wrong. Your agent fixes it. Clearer feedback in. Better fixes out. Found it. Filed it. Stack trace attached. No more “which page were you on?” Stuck? Say so. Support sees exactly where. Point at the typo. It's an issue. Website review, without the email thread. Testers click. Issues appear, details attached.
Your users spot what's broken, often before you do, and they won't always tell you. quibble gives them a button: they click the thing that's wrong and write a sentence. You get a to-do in the tool your team already uses (GitHub, Jira, Linear and others) with everything needed to fix it, and no follow-up questions.
Vibe coding is fast. Cleaning up after it isn't: the agent fixes the wrong button, breaks something two pages away, and tells you it verified the fix. quibble makes the running app the judge. Point at what's wrong, and the issue carries the page, the element, the error and the build. When the agent says "fixed", check the page, not its summary.
When customers get stuck, the first three replies are usually questions: which page, which account, what did it say? quibble gives them a help button right where it happened. Your team gets the page, who's asking and the error that appeared, in the tool they already use.
Your testers find the bugs, then spend as long again writing them up. With quibble they click what's broken and write a sentence. It lands on your team's to-do list with the page, the browser and the error already filled in, so nobody copies and pastes.
Website reviews drown in screenshots and "the heading on the second page". With quibble, reviewers click the heading, picture or link they mean and write a sentence. Each comment becomes a to-do for your team, showing exactly where on the page it was.
Email for early access Try it live
Free for small companies. Nothing passes through our servers. About ten minutes to add.
Developers: how it works · install it with your coding agent · three places it works.
The trouble with quibbles
They start small: a button that does nothing, a heading that wraps wrong on a phone. Fuzzy little problems. A user tells you about one, and the questions start: which page were you on? Which browser? Can you send a screenshot? By the time you know enough to fix it, they've moved on.
The rest, nobody mentions. They multiply quietly, and one day you open the backlog and it's full of them, bulkhead to bulkhead. You end up fixing your best guess of what people meant.
Telling you about a problem should be easier than putting up with it.
Which page were you on?
What browser was that?
Can you send a screenshot?
Works for me…
What it's like with quibble
You know exactly where
Every note comes with the page, the thing they pointed at and the error the page threw. Nobody has to describe it.
You hear from people who'd never write in
A click and a sentence, without leaving the page. Less effort than putting up with the problem.
You start on the fix
It's already in the tool your team uses, with your tags and on your priority scale. No inbox to sort.
Three places it works
In your browser
The quibble extension, on any site, including ones you can't change. Nothing to add to the site. About the extension
In your app
Built into your app, so everyone who signs in gets the button on every page. About quibble in your app
On your computer
A companion that runs beside a desktop app, a local tool or the app you're developing, in any language. About the companion
Three steps, and you're done asking
-
Add the button
A developer adds it once, in about ten minutes, or hands it to a coding agent. No new service to run.
-
People point and say it
They click the thing that's wrong and write a sentence. No account on your team's tool, and no screenshot to attach.
-
You fix it
It arrives as a to-do in the tool your team already uses, with the page, the browser and the error attached.
We've been on the other end of “it's broken”
We've asked “which page were you on?” more times than we'd like to admit. So quibble is built around one idea: the person who found the problem points at it, and everything else is filled in for them.
- Works with six trackers: GitHub, GitLab, Gitea, Forgejo, Jira and Linear. How each is tested.
- Nothing passes through our servers, because there aren't any. A note goes from the person's browser to your app, and from your app to your tracker.
- No new vendor to approve: no extra data processing agreement, subprocessor or security review.
- See it before you believe it: the live demo runs the real quibble in your browser.
- Their browserA user spots a problem
- Another company’s serversYour users’ notes are stored by someone else
- Your to-do listA copy is sent on to you
- Their browserA user spots a problem and clicks quibble
- Your appquibble adds the page, the error and who sent it
- Your to-do list GitHub, Jira, Linear…It arrives as an issue, ready to fix
Nothing passes through quibble. There’s no quibble server to pass through.
Watch it work
Under a minute, unedited: quibble added to a pretend app, a note filed while pointing at the broken button, an invented tag dropped, and a private box that never leaves.
The live demo runs quibble itself in your browser. Nothing you type leaves it.
Which one sounds like you?
Vibe coding is fast. Cleaning up after it isn’t.
Wrong button, loosened tests, “verified” without a browser. Judge the agent by the running page.
Your users found the bug. They just didn’t tell you.
The intermittent ones arrive with the moment they happened: page, browser, error, who.
Five reviewers, three versions, one launch date
Every comment gets an address and a status. Launch when the list is empty.
“Can’t reproduce.” Closed.
The failed request, the console line and the build, captured at the click.
Three emails to learn which page they were on
The facts first, and no card numbers in your inbox.
What arrives with every note
Always
What they wrote, the page they were on, its title, where they came from, their screen size, browser, language and time zone.
Who sent it
Their name from the sign-in you already have. Without one, they can type it, and the issue says it's self-declared.
When something broke
The last five JavaScript errors the page threw, folded away under Diagnostics until you want them.
When they choose
The element they pointed at. A screenshot, with any region you mark private blanked out.
Additional context you need
Console output, failed network requests and any fields your app wants to add. Off until you turn them on.
The small print, in your favour
FYI your categories stay tidy
People can only use the tags your team already has; anything else is dropped. Ask for a P0 and quibble files a P1.
uiurgent-customer-facingP1
FYI nobody needs an account to complain
quibble knows who they are from your app's sign-in: Cloudflare Access, SAML, OIDC, oauth2-proxy or mTLS. Without one, a typed name is marked self-declared.
FYI there's nothing new to look after
No extra service, database or server. Notes are stored as issues in your tracker. quibble runs inside the app you already deploy.
Stop chasing the details
Without it
- “It's broken”, and three emails to find out where.
- Problems nobody reports, and people who quietly give up.
- Fixes built on a guess.
With quibble
- The page, the element and the error, in the first message.
- Reporting takes less effort than putting up with it.
- You start on the fix, not a conversation.
Works with what you already use
Trackers
| Tracker | Status |
|---|---|
| GitHub | In production use |
| Gitea | Tested on 1.27.3 |
| Forgejo | Tested on 12.0.4 |
| GitLab | Tested on 19.4.1 CE |
| Jira Cloud | Tested on Jira Cloud, 2026-09-30 |
| Linear | Tested on Linear, 2026-10-08 |
| GitHub Enterprise Server | Not yet tested |
| Jira Data Center / Server | Roadmap |
| Azure DevOps | Under consideration |
| Redmine | Under consideration |
| Bitbucket Data Center | Under consideration |
Languages
| Language | Status |
|---|---|
| Python | Supported |
| Any other stack By implementing quibble's documented schema. | Supported |
Apps in any language on your computer, with quibble serve as a companion. A hosted app in another language implements quibble’s documented schema. | Local apps |
Get quibble into your app
quibble is in early access, free for small companies, and early teams keep the price they joined at. Send an email to hello [at] quibble [dot] fyi.