# How we turn feedback into a roadmap

On a schedule, an agent gathers feedback from support, public reviews, and a Slack channel, clusters it into themes with representative quotes and counts, and creates or updates a Linear issue per theme.

Canonical page: https://openchatly.com/use-cases/user-feedback

Product feedback arrives everywhere: support threads, public reviews, a Slack
channel where people drop what they hear. The same request shows up in all three,
worded differently each time, and never gets counted. A theme that a hundred
people asked for looks the same as a one-off, because nothing pulls the mentions
together.

We run a feedback agent on Kortix that gathers those sources on a schedule,
clusters them into themes, and keeps a Linear issue per theme up to date. It reads
the feedback and writes to Linear; people still own prioritization. This is how we
keep our own roadmap grounded in what users actually ask for.

- **Team:** Kortix
- **Runs on:** Scheduled cron
- **Connected systems:** Plain · G2 / app stores · Slack · Linear
- **Mode:** Reads feedback · writes Linear issues

## The problem

Feedback is scattered across support threads in Plain, public reviews on G2 and
the app stores, and an internal Slack feedback channel. The same underlying
request appears in all of them, phrased differently, so it never gets counted. A
theme that keeps recurring is indistinguishable from a single loud comment.

The common approaches don't add up to a roadmap. Reading each source by hand is
slow and inconsistent, and whoever reads it weighs it differently. A tag in the
support tool captures support but not reviews or Slack. A spreadsheet of feature
requests goes stale the moment someone stops maintaining it, and it still doesn't
tell you how many people asked for the same thing.

## What we built

On Kortix, a scheduled cron triggers an agent. It spawns an isolated session (a
cloud sandbox) with read access to Plain, the public review sources, and the Slack
feedback channel, and write access to Linear. It gathers the feedback, clusters it
into themes with representative quotes and counts, and creates or updates a Linear
issue per theme, so the same request is deduplicated and quantified instead of
scattered.

## How it works

### Copy the setup prompt into a new session

Open your Kortix workspace, start a new session, paste this prompt and send it.
The agent writes the agent file, the clustering skill and the weekly trigger, and opens a change request for you to review. Prefer
clicks? Choose **Use this template** instead.

**Setup prompt**

```
Set up a feedback clustering agent in this workspace.

1. Create the agent agents/user-feedback.md. Its job is to turn user feedback into one Linear issue per theme. It may use the Plain and Linear connectors and read the #feedback Slack channel.

2. Create the skill skills/feedback-clustering/SKILL.md with these rules:
   - Read the open issues in the Feedback team in Linear first, so new feedback joins an existing theme.
   - Read recent Plain threads, our G2 reviews and the #feedback channel, all read-only.
   - Two mentions are one theme when they ask for the same capability or fix, even in different words or from different sources.
   - For each theme, pick the clearest verbatim quote and an action-oriented title.
   - Update the matching issue's quotes, mention count and sources, or create one new issue. Never create a duplicate.
   - Never set priority, assign an owner or close an issue.

3. Add a cron trigger feedback-sweep to kortix.yaml. It runs the user-feedback agent every Monday at 06:00 with the prompt "Load the feedback-clustering skill and run one complete feedback sweep into the Feedback team in Linear."

4. Tell me which of these connectors are not connected yet.

5. Open a change request with all of it. Do not merge it.
```

### Connect your tools

Open **Connectors** in your workspace and connect your support inbox, your issue
tracker and Slack. Credentials are brokered server-side and never enter the
agent's machine.

- **Plain** (Required):
Reads recent support threads, read-only.
- **G2** (Optional):
Supplies public reviews to cluster with the other feedback.
- **Linear** (Required):
Creates or updates one issue per feedback theme.

### Run it once with this prompt

Merge the change request, then start a session with the **user-feedback** agent
and send this prompt. Check the themes it created before you let the schedule
take over.

**Prompt**

```
Run one feedback sweep.

1. Read the open issues in the Feedback team in Linear.
2. Read the last 7 days of Plain threads, our G2 reviews and the #feedback channel. Change nothing in them.
3. Cluster the feedback into themes by the underlying request, not the wording.
4. For each theme, update the matching Linear issue's quotes, count and sources, or create a new issue in Feedback.
5. Do not set priority, assign anyone or close anything. Tell me which issues you created and updated.
```

### Let the weekly schedule take over

The change request added this trigger to `kortix.yaml`. From now on the agent
runs every Monday at 06:00, each run in a new session on its own cloud computer.
To change the time, edit the cron line, or open **Triggers** in the workspace.

**kortix.yaml**

```yaml
triggers:
  - slug: feedback-sweep
    name: Feedback theme sweep
    on:
      cron: "0 0 6 * * 1"
    run:
      agent: user-feedback
      prompt: Load the feedback-clustering skill and run one complete feedback sweep into the Feedback team in Linear.
```

### Leave priority to people

The sources stay read-only, and the agent's only write is creating and updating
Linear issues. It never sets priority, assigns an owner or closes an issue, even
one that looks like a duplicate. People weigh each theme against the roadmap.

### Read the sweep summary

Each run ends with a list of the Linear issues it created and updated. This is what a run looks like
in the session:

> **Feedback theme sweep · Mon 06:00**
>
> Prompt: Load the feedback-clustering skill and run one complete feedback sweep into the Feedback team in Linear.
>
> Read **63** pieces of feedback and found **8** themes. Updated **6** existing
> issues and created **2** new ones in Feedback. The largest theme, bulk export,
> now has **27** mentions across three sources.

> **The pattern**
> A scheduled **cron** spawns a session with read **connectors** into Plain, the
> public reviews, and Slack, and a write connector into Linear. The clustering
> lives as **skills** and **memory**. The agent quantifies the themes; people own
> what to build.

## Make it do more

Once it works, paste any of these into the same session.

**Weekly theme digest**

```
After each sweep, post the five themes with the most new mentions to #product, with one quote each.
```

**Close the loop with users**

```
When a theme's Linear issue is marked done, list the Plain threads behind it so support can tell those users.
```

**Add app store reviews**

```
Also read our App Store and Google Play reviews as a source, the same way as G2.
```

## Guardrails

The agent reads several feedback sources and writes to Linear, so its access is
scoped to exactly that:

- **Isolation.** Every run happens in its own isolated sandbox. The session is granted access only to the sources it's scoped to, and only the Linear writes are written back out.
- **Scoped secrets.** The Plain, review-source, Slack, and Linear credentials are
  encrypted in the Secrets Manager and injected into the sandbox at runtime, scoped to the agents you grant them to.
- **Read-only sources, scoped writes.** The feedback sources are read-only; the
  only write is creating and updating Linear issues. The agent does not prioritize,
  assign, or close.
- **Everything is code.** The agent's clustering rules, skills, and per-system
  permissions are files in the repo, versioned and changed through a reviewed
  **change request** rather than a dashboard setting.

## The outcome

- **Every run:** Feedback gathered, clustered, and reconciled to Linear
- **One per theme:** The same request deduplicated instead of scattered
- **4 sources:** Support, reviews, and Slack into one issue tracker

Feedback that used to sit unread across support, reviews, and Slack now arrives as
a set of quantified themes, each a single Linear issue with quotes and a count.
The agent does the gathering and counting; the team still owns which themes become
roadmap.
