Skip to content

The moment it happens

Send new Linear bugs to the team that owns them

Each new bug lands with the right team in Linear within seconds, and that team hears about it in Slack.

Runs
The moment it happens
Apps
Linear, Slack
AI
Yes, uses the built-in AI allowance
Access
Linear write, webhook admin; Slack chat:write

Send this to your assistant

Create a ClickRuntime automation: when a new Linear issue with the Bug label is created, use AI to decide which team owns it from my team descriptions, move it there and post it to that team's Slack channel.

Paste it into your assistant. It tells you what it will send or change before it runs live.

First time? Adding ClickRuntime to your assistant takes about two minutes.

Why use it

Why teams use this automation

A product company with four engineering teams sends every bug report into one shared triage queue. Someone on rotation reads each one, works out whether it belongs to payments, mobile, web or platform, and moves it by hand. On busy days bugs sit in triage for a day or more, and the team that owns a bug often learns about it from an annoyed customer rather than from Linear.

With this automation, each new bug is read the moment it is created, matched against short descriptions of what each team owns, moved to that team and announced in its Slack channel. Bugs it cannot place with confidence stay in triage with a note, so nothing is misrouted silently.

What you get out of it

  • Bugs reach the owner in seconds

    The team that can fix a bug sees it as soon as it is filed, not after the next triage session. Urgent problems get attention while they are still small.

  • Triage rotation gets lighter

    The person on triage only handles the bugs that are genuinely unclear. Clear-cut reports are moved for them, which frees most of that time for real engineering work.

  • Routing follows your own team descriptions

    You describe what each team owns in plain words, such as checkout, invoices and refunds for payments. When ownership changes, you update a sentence rather than retraining anyone.

  • Unclear bugs are flagged, not guessed

    When a report could belong to several teams, it is left in triage and the channel is told why. A wrong move is worse than no move, so the automation stays cautious.

  • Every team sees its new bugs in Slack

    Teams that live in Slack do not have to keep a Linear view open to notice incoming work. The message links straight to the issue so someone can pick it up.

How it works

What happens, step by step

  1. Linear lets ClickRuntime know the moment a new issue is created.

  2. If the issue has the Bug label, AI reads its title and description and compares them with the team descriptions you wrote.

  3. When one team is a clear match, the issue is moved to that team in Linear.

  4. A message with a link to the bug is posted in that team's Slack channel, or in your triage channel if no team was a clear match.

Before it runs live

  • Connect Linear
  • Connect Slack, then invite the app to the channel (type /invite @ClickRuntime there)
  • Paste your automation's link into the other app's webhook settings

What you get

RunsThe moment it happens
Send new Linear bugs to the team that owns themjust nowSucceeded
Slack · #paymentsNew bug for payments: Refund button does nothing on Northwind invoices https://linear.app/acme/issue/PAY-412

Build your own

Need it to work differently?

This template is a starting point. Copy the prompt and change it, or describe a different automation from scratch, with your own conditions, more apps or an AI step. Your assistant writes it, tests it and runs it on ClickRuntime.
  • Your own rules

    Conditions, thresholds, filters and exceptions, written the way you'd explain them to a colleague.

  • Any number of apps

    One automation can read from one app and update several others. Over 248 apps are ready, and anything with an API works too.

  • AI where it helps

    Summaries, classification, extraction and drafts use ClickRuntime's built-in AI, with no extra key.

  • On a schedule or on each event

    Runs as often as every 5 minutes, or the moment an app sends an event, and keeps track of what it already handled.

Changes you can ask for

  • Act only on the items that match your own rules, and skip the rest
  • Change what the AI looks for, or how it writes the result
  • Add another app, for example also send it to Google Sheets
  • Combine it with other Linear and Slack steps into one automation

Under the hood

The code that runs this automation

This is the Python script that runs each time the automation starts. Your AI assistant writes it for you when you send the prompt, and you allow each step in your assistant. To change how the automation works, describe the change to your assistant and it updates the script for you. For every function it can use, see the script reference.
route_new_linear_bugs_to_the_right_team_with_ai.pyexample
from clickruntime import on_event, credentials, http, ai, notify, log

TEAMS = {"payments": ("TEAM_ID_PAYMENTS", "#payments", "checkout, invoices, refunds"),
         "mobile": ("TEAM_ID_MOBILE", "#mobile", "iOS and Android apps, push notifications"),
         "web": ("TEAM_ID_WEB", "#web", "website, dashboard UI, browser issues")}

@on_event
def handle(event):
    body = event.json or {}
    issue = body.get("data") or {}
    labels = [l.get("name", "").lower() for l in issue.get("labels", [])]
    if body.get("action") != "create" or "bug" not in labels:
        return {"skipped": True}
    guide = "\n".join(f"{k}: {v[2]}" for k, v in TEAMS.items())
    text = f"{issue.get('title', '')}\n{(issue.get('description') or '')[:2000]}"
    try:
        team = ai.generate(f"Teams:\n{guide}\n\nBug:\n{text}\n\nAnswer with one team name or 'unsure'.",
                           max_output_tokens=10).text.strip().lower()
    except ai.AIError as e:
        log.warning("AI unavailable", {"code": e.code})
        team = "unsure"
    if team not in TEAMS:
        notify.slack(f"Could not place bug: {issue.get('title')} {issue.get('url', '')}", channel="#triage")
        return {"moved": False}
    team_id, channel, _ = TEAMS[team]
    http.post("https://api.linear.app/graphql", headers={"Authorization": credentials.secret("LINEAR_API_KEY")},
              json={"query": "mutation($id:String!,$t:String!){issueUpdate(id:$id,input:{teamId:$t}){success}}",
                    "variables": {"id": issue["id"], "t": team_id}})
    notify.slack(f"New bug for {team}: {issue.get('title')} {issue.get('url', '')}", channel=channel)
    return {"moved": team}

FAQ

Common questions

How does it decide which team owns a bug?
It compares the bug's title and description with a short description of each team's area that you write once, such as 'mobile: iOS and Android apps, push notifications'. Clear, specific descriptions give the best results.
What happens to bugs that do not match any team?
They stay in your triage team and a message is posted to your triage channel saying the bug could not be placed. Someone can then move it by hand.
Does it only look at issues labelled Bug?
Yes. Feature requests and other issues are ignored, so only bug reports are moved. You can name a different label if your workspace uses one such as Defect.
What permissions does it need?
Linear write, webhook admin; Slack chat:write. Nothing else in your accounts is used.
Does it need AI?
Yes. It uses ClickRuntime's built-in AI, so you don't need an OpenAI or Anthropic key. Every plan includes a monthly AI allowance.
How many runs does it use?
One run for each event the app sends.
Can I change how it works?
Yes. Describe the change to your AI assistant, for example a different schedule, channel or filter. It updates the automation, tests it and tells you what changed.

Set up “Send new Linear bugs to the team that owns them” from your assistant

Copy the prompt above, or connect your assistant first. Free plan, no credit card.