Introducing Maestrio: feedback to PR in minutes

Every product team has the same broken loop. A user spots a bug or wants a small feature. They mention it in a Slack DM, an email, a support thread, or — worst of all — they just give up and never tell you. The lucky reports survive long enough to be triaged into a backlog, where they wait for an engineer to pick them up, page back into the relevant part of the codebase, write the fix, open a pull request, and merge it. By the time the user hears back, half of them have already moved on.

The cost isn’t the time spent on any single fix. It’s the friction along the entire path between “this is broken” and “this is fixed in production.” That friction is where features die and where small bugs grow into churn.

Maestrio exists to close that gap.

What Maestrio is

Maestrio is two things working together: an embedded feedback widget that lives inside your product, and a set of AI agents that turn the feedback it collects into pull requests against your repository. A user clicks the widget, reports a bug or suggests a feature, and within a couple of minutes Maestrio’s agents have triaged the request, drafted a plan, written the code, and opened a PR for you to review. You stay in the loop where it matters — reviewing plans you’re unsure about and merging the result — and skip the parts that were always going to be mechanical.

The widget is a single floating button you drop into your app. The pipeline behind it is wired into your GitHub repository through a Maestrio app you install once.

How the loop actually works

The end-to-end flow takes about a minute on a simple change. Here’s what happens after a user submits a report:

1. The widget captures the request along with the identified user and any context you pass in. It lands in your project’s pipeline with status Received.
2. The AI triages it. It reads the report, looks at the project, and produces a plan with a confidence score.
3. The confidence threshold decides what happens next. You set this per-project — say, 70%. Anything at or above the threshold goes straight to coding. Anything below is parked in Needs review, where you can read the plan, chat with the AI to adjust it, and approve when you’re happy.
4. The agent writes the code and opens a pull request against the linked repository. You can see the diff, browse the changes, and treat it like any other PR.
5. A GitHub bot stays on the PR. Need a tweak? Have a question about why the agent did something a particular way? Comment on the PR. The bot answers, and if your comment requires a code change, it pushes a new commit to the same branch.
6. You merge. Maestrio notifies the user that the thing they reported has shipped.

The thing that surprised me building this is how much of the value is in step three. It’s tempting to imagine a fully autonomous loop where AI handles every report end-to-end. In practice, what you actually want is a developer-shaped checkpoint at the plan stage, not the code stage. Reviewing a written plan takes seconds. Reviewing 400 lines of generated code takes much longer and is much harder to do well. Maestrio puts the human review where it pays for itself.

Why the confidence threshold matters

The threshold is the dial that lets a team grow into trusting the system. Set it high and almost everything routes through human review — useful when you’re getting started, or for sensitive parts of the codebase. Lower it as you get a feel for where the AI’s plans are reliable. Whatever you choose, the agent is honest about its own confidence: it doesn’t sneak low-confidence work past you, and it doesn’t gold-plate high-confidence work into a needless review queue.

A simple CSS fix will usually breeze straight through to a PR. A change that touches your auth flow will sit in Needs review with a plan you can interrogate before a single line is written. That asymmetry is the point.

Getting started

Setup is about five minutes if you have a Maestrio account, a repo, and a project to drop the widget into.

1. Install the GitHub app. From your Maestrio dashboard, go to Settings → Integrations and install the Maestrio app on the repositories you want it to act on. You can scope it to a single repo or grant access to your whole org.

2. Create a project and link your repos. A Maestrio project can contain multiple GitHub repositories — useful for monorepos or front-end/back-end splits. In the project’s settings, pick the repos and set the AI confidence threshold (70 is a sane starting point).

3. Generate an API key and grab your project ID. The API key lives under Settings → API. The project ID is shown on the project page. You’ll need both for the SDK.

4. Install the SDK. Either install it manually:

npm install @maestrio/sdk

…or, if you want a shortcut, the dashboard offers a prompt you can paste into your AI assistant of choice. It reads your project, installs the package, and wires up the initialization for you. Either path lands you in the same place.

5. Initialize and identify. The minimal integration is three function calls:

import { createMaestrio } from "@maestrio/sdk";

const maestrio = createMaestrio({
  apiKey: "mst_live_abc123",
  baseUrl: "https://app.maestrio.ai",
  projectId: "proj_xyz",
});

maestrio.identify("user-123", {
  name: "Jane Doe",
  email: "jane@example.com",
});

maestrio.show();

identify() is what attaches reports to a real user in your dashboard, so you can follow up with them when the fix ships. If you’d rather skip the explicit show() call, pass { autoShow: true } as the third argument to identify() and the widget will appear as soon as the user is known.

6. Add allowed domains. Under Settings → API, list every domain that should be allowed to call the Maestrio API on behalf of your project. Don’t forget to add http://localhost:<port> while you’re developing — it’s the most common reason a first integration silently fails in dev.

That’s the whole setup. From here, every request a user submits flows through the pipeline I described above.

Conclusion

The widget is fully customizable — colors, position, labels, copy — so it ends up looking like part of your product rather than a third-party panel bolted on. The full configuration reference is in the Maestrio docs, and there’s an end-to-end demo of the setup and pipeline below:

If your team is sitting on a feedback backlog that never quite gets worked through, or if you’ve ever lost a feature request to the gap between user wrote a message and engineer had a free hour, Maestrio is built for exactly that gap. Try it on a side project first, set the confidence threshold high, and watch where the human-in-the-loop actually adds value. You’ll find it.