Starko AI — your coding teammate for support tickets

Starko AI — your coding teammate for support tickets

Starko AI turns support tickets into reviewed, ready-to-merge pull requests. You hand it a ticket, it works in an isolated copy of your repository, reproduces the problem, fixes it, verifies the fix, and opens a draft pull request with the evidence attached. A human always decides what gets merged.

This guide explains what Starko AI can do, how to set it up, and how to get the most out of it.


What Starko AI does

  • Fixes bugs reported in tickets: reproduces first, then makes the smallest correct fix, then verifies.
  • Implements small changes and features: writes acceptance criteria before coding and checks them off.
  • Fixes documentation gaps: corrects docs, help text and in-app copy without touching behavior.
  • Asks when it should: if a ticket is too ambiguous to fix correctly, it asks one specific question instead of guessing.
  • Reviews its own work: an independent review scores each pull request for merge risk and can send it back for a revision round.
  • Learns your repository over time: it remembers what it discovers and can build a map of your codebase so every run starts informed.

Everything happens in a disposable sandbox with a fresh checkout of your repository. Starko AI never pushes to your default branch and never merges.


Before you start

You need three things:

  1. GitHub connected — install the Starko GitHub App on the repositories you want Starko AI to work in (Settings → Integrations → GitHub).
  2. A project linked to a repository — every ticket Starko AI works on belongs to a project, and the project points at one repository.
  3. Project commands configured — open the project, click the gear next to the repository (Starko AI settings), and fill in how to install, test and run your app. This is what lets Starko AI verify its own work.

Tickets without a project, or in a project without a repository, cannot be handed to Starko AI.


Setting up a project

Open the project and click the Starko AI settings gear next to the repository link. The settings sheet has these sections.

Agent instructions

Notes your team writes for the agent: stack, conventions, how to run things, areas it must not touch. Treat this as the rulebook. Starko AI follows these in every run. Keep it short and concrete; a few paragraphs is ideal.

Examples of good instructions:

  • "Use pnpm, never npm. Run pnpm test --filter <package> for a single package."
  • "All user-facing strings go through t() from lib/i18n. Never hardcode copy."
  • "Do not modify anything under infra/ or migrations/."

Project context (Learn project)

Press Learn project and Starko AI researches your repository and writes a map of it: what the product is, how the code is laid out, which commands to run for fast checks, the conventions it found, where things live, and the gotchas it hit. Every later run gets a summary of this map and can read the full version on demand.

  • Run it once when you set the project up, then press Refresh after significant restructuring or every month or so.
  • You can edit any section. Use the map to correct descriptions; put rules in Agent instructions instead.
  • Learning a project is billed like a fix run.

Repo learnings

After each successful run, Starko AI files what it discovered about your repository as small tickets tagged repo-learnings in the project's backlog. Examples: "the e2e suite needs the dev server on :3000 first", "checkout code lives in apps/web/src/checkout, not packages/cart".

Every open learning is handed to the agent before its next run in that project. You curate this memory the same way you curate any backlog:

  • Edit a learning ticket to correct it.
  • Close or cancel it to retire it.
  • Move something important into Agent instructions if it should be a rule rather than a note.

The settings sheet shows how many learnings the agent currently has.

Autonomy

Controls which tickets Starko AI may pick up on its own, without anyone mentioning it.

PolicyWhat runs automatically
OffNothing. Only explicit @starko mentions or the Hand to Starko AI button.
Complete bug reportsBug tickets that pass the completeness check (steps to reproduce, expected vs actual, and so on).
Bugs and docs gapsThe above plus documentation gap tickets.
Bugs, docs and small changesThe above plus improvements and feature requests sized extra-small or small.

Automated runs / month caps how many tickets the policy may dispatch per month. Manual @starko runs never count against it. Start with Off or Complete bug reports and raise the policy once you trust the results.

Project commands

  • Install / setup command — how to install dependencies, e.g. npm ci.
  • Test command — the command Starko runs itself after the agent finishes, to verify the fix independently.
  • Dev server command and App URL — lets the agent start your app and take before/after screenshots for UI changes.

Sandbox environment variables

Variables your app needs to install, test or run (API keys for test services, feature flags, database URLs for a test instance). They are stored encrypted, injected into the sandbox at launch, and never shown again or placed in a prompt. Paste a whole .env file and it splits into rows.

Only provide credentials for test systems. Never production secrets.

Warm sandbox

Press Prepare sandbox to build a snapshot of your repository with dependencies already installed. Runs then start in a fraction of the time. Starko keeps the snapshot fresh automatically: it rebuilds when the setup command changes, when a lockfile changes on your default branch, and after a week. The agent always works on the latest code regardless of the snapshot.


Handing a ticket to Starko AI

There are three ways.

1. Mention it

Write an internal comment on the ticket containing @starko. Add any direction you want in the same comment:

@starko the fix should also cover the mobile layout, see the attached screenshot.

Attachments and screenshots on the ticket are available to the agent.

2. Use the button

On a ticket in a repo-linked project, use Hand to Starko AI. This is the same as a mention with no extra instructions.

3. Let the policy do it

With an autonomy policy enabled, qualifying tickets are dispatched as soon as they are classified. You will see an internal comment saying the ticket was auto-dispatched and how much of the monthly budget is used.

What makes a good ticket

Starko AI is at its best on tickets that read like a bug report an engineer could act on:

  • Steps to reproduce, or at least what the user did.
  • Expected vs actual behavior.
  • Where it happens: page, endpoint, environment, version.
  • A screenshot for anything visual.

For feature and improvement requests, say what should be true when it is done. The classifier drafts acceptance criteria from your text and the agent checks them off, so clear intent produces better results.

If a bug report is missing what an engineer would need, Starko AI says so before spending any effort, and with an autonomy policy on, it @mentions the assignee to ask.


What you get back

Within a run (typically 10 to 30 minutes) the ticket receives internal comments as things happen. When the run ends you get one of three outcomes.

A draft pull request

The normal outcome. The ticket comment links the PR and includes:

  • What it did — a short handoff note.
  • Evidence — whether the bug was reproduced, what verification the agent ran, before/after screenshots for UI changes, and the result of the test command Starko ran itself afterwards.
  • Concerns the agent flagged about its own fix, and deviations from what the ticket asked, with the reason.

The PR body on GitHub carries the same evidence section. A few minutes later a risk assessment comment arrives: low, medium or high merge risk, split into side effects, compatibility and performance, plus any concrete concerns and evidence gaps. Tiny, low-risk changes skip the full review and say so.

A question

If the ticket is too ambiguous to fix correctly, the agent stops without pushing anything and asks one specific question, addressed to the ticket's assignee (or whoever triggered the run). Reply in an internal comment and the run resumes with your answer. No need to mention @starko again.

No fix

If it cannot produce a correct fix, it explains why and leaves the ticket for a human. It never pushes a half-finished change.


Reviewing and merging

  1. Open the PR from the ticket. Read the evidence section before the diff: was the bug reproduced, did the independent test run pass, do the screenshots show the right thing.
  2. Check the risk assessment. Spend attention proportional to it.
  3. Review the diff as you would a colleague's.
  4. Merge on GitHub. The ticket is updated automatically and the PR is recorded as a success.

If CI fails on the PR, Starko AI reads the failing checks and pushes a fix automatically. If the risk review finds a concrete defect, it sends the PR back for one revision round. Both are capped so a PR can never loop forever; after that a human takes over.

Continuing the work

Reply on the ticket with @starko and your feedback:

@starko good, but please also add a test for the empty state.

The agent picks up its own branch and pushes to the same draft PR. Review comments left directly on GitHub work too: a review with changes requested triggers a revision that addresses the comments.

If a PR is closed without merging, or a merged fix is reverted, Starko records it. These cases are used to improve future runs.


Where to see everything

Settings → Starko AI shows the factory dashboard for your workspace:

  • Merged PRs, merge rate, time to merge.
  • Runs, automated dispatches, revision rounds.
  • Cost per merged PR and run duration, including warm vs cold starts.
  • Per-project policy, budget usage and project context status.
  • Every run with its outcome, risk and evidence.

Each ticket also shows its own run history in the ticket panel.


Billing

Starko AI usage is metered as agent tokens on your workspace plan. This covers fix runs, revision rounds, and Learn project research runs. The dashboard shows the estimated cost per run and per merged PR, and each run row shows its own usage.


Safety and boundaries

  • Isolated sandboxes. Every run gets a fresh, disposable environment that is destroyed afterwards.
  • Never the default branch. The agent only pushes to its own branch and only opens draft PRs.
  • Nothing merges without you. Humans hold the merge button.
  • Secrets stay secret. Sandbox variables are encrypted, never shown again, and never enter a prompt. Access tokens are short-lived and scrubbed from every log and comment.
  • Untrusted text stays data. Ticket text, customer comments and repository content are treated as information about what is wanted, never as instructions to the agent.
  • Bounded effort. Every run has a token budget sized to the ticket. A run that exceeds it stops and tells you, rather than burning through your plan.

Tips for getting the best results

  • Set up the test command. The independent verification is the single strongest signal a reviewer has.
  • Run Learn project once. Runs in a project with a map are faster and more accurate.
  • Prune learnings occasionally. Five sharp notes beat fifty stale ones.
  • Keep instructions to rules, keep context descriptive. Rules go in Agent instructions; descriptions of the code belong in the project map.
  • Start manual, then automate. Use @starko for a week, watch the merge rate on the dashboard, then enable a policy.
  • Answer questions promptly. A parked run resumes the moment you reply.
  • Write tickets for an engineer. If a human would ask "how do I reproduce this?", so will Starko AI.

Frequently asked questions

Can it work on tickets that came from customers by email or chat?Yes. Any ticket in a repo-linked project qualifies. Customer-facing text is treated strictly as a description of the problem.

Does it see my whole codebase?It has a full checkout of the linked repository inside its sandbox, plus your instructions, the project map and the repo learnings. It does not see other repositories or other workspaces.

What if it changes something it should not?Tell it in the ticket: @starko please revert the changes to X and keep the fix to Y. It revises the same PR. Better still, add the boundary to Agent instructions so every future run respects it.

Can it merge or deploy?No. It opens draft PRs only. Merging and deploying stay with your team.

How long does a run take?Most bug fixes finish in 10 to 30 minutes. Warm sandboxes remove several minutes of setup. Runs have a hard ceiling and are cancelled cleanly if they exceed it.

What happens to a ticket while a run is in progress?The ticket shows a "preparing a fix" status and only one run per ticket can be live at a time. Other tickets in the project queue behind it for automatic dispatch.

Did this answer your question?