Gathers a bug report, feature request or feedback in conversation and routes it to the in-app Report a Problem dialog, the public issue forms, or SECURITY.md for a vulnerability (never a public issue); load when the user wants to report a problem, send feedback or suggest an improvement.
Install
npx skillscat add kirodotdev/kirocrew/feature-request Install via the SkillsCat registry.
Feature Request / Issue Report
Conversational workflow for gathering user feedback and creating GitHub Issues
on the Kiro Crew repository.
Trigger: User says "report a bug", "report a problem", "feature request",
"send feedback", "I have an idea", "something's broken", or names$feature-request. The dashboard's "Request a
Feature" button does NOT load this skill: it seeds the self-contained promptFEATURE_REQUEST_PROMPT_FALLBACK in website/src/prompts/featureRequest.ts,
which must be kept in step with the workflow below.
Repository
https://github.com/kirodotdev/KiroCrewRoute it first
Before gathering details, decide where the report belongs. Take the first case
that fits:
A security vulnerability. Do not draft it, search for it or file it.
Give the user the security policy and tell them to report it privately by
the email address that file lists, with the[SECURITY]subject prefix —
never in a public issue:https://github.com/kirodotdev/KiroCrew/blob/main/SECURITY.mdSomething broke on this install. Point the user to the Report a
Problem dialog (Settings › About › Support › Report a Problem, or the
nav rail's Report issue link). It collects a redacted diagnostics bundle
and opens a pre-filled bug report on this install's tracker. Without the
dashboard,kirocrew doctor --bundlebuilds the same bundle and prints the
link. If the user would rather file it from this conversation, continue with
the workflow below as a bug report.A question, or an idea not yet ready to be a request. Point the user to
Discussions:https://github.com/kirodotdev/KiroCrew/discussionsAnything else — a feature request, a bug to file from this conversation,
or feedback. Continue with the workflow below.
Shell safety (READ FIRST)
Everything the user types is untrusted. Never interpolate raw user text
(titles, descriptions, search keywords) into a shell command string, and never
put it in a shell heredoc — a heredoc ends on a line equal to its delimiter,
so a body containing a line that is exactly EOF (or whatever delimiter you
pick) would terminate it early and let the following lines execute as shell.
Follow these rules for every gh invocation below:
- Body & title: write them to temp files using your own file-writing tool
(not a shell heredoc, notecho/cat >), then feed those files togh.
Create the files withmktempso the path is unpredictable and
per-invocation (no fixed/tmp/...name to clobber or symlink-attack). - Pass the body with
--body-file "$BODY_FILE"(never--body "..."). - Load the title via command substitution into a double-quoted variable —
TITLE="$(cat "$TITLE_FILE")"— then pass--title "$TITLE". Command
substitution assigns the text literally (it is not re-parsed as shell) and
the double quotes contain word-splitting/globbing. - Search keywords: derive a few plain alphanumeric words yourself from the
conversation and pass them as a double-quoted literal. Do not paste raw user
text (with its punctuation/metacharacters) into the search string. - If you cannot safely pass a value, fall back to the copy/paste option
(Option 1) instead of shelling out.
Workflow
1. Greet & Identify
Ask the user what they'd like — a feature request or a bug report. Keep it
casual. Don't present a form.
2. Gather Details Conversationally
Guide the user to describe:
- What they want (or what's broken)
- Why it matters (what problem it solves)
- Any context (how they hit it, what they tried)
Don't force structure. Ask follow-up questions if the description is vague.
Two to three exchanges is usually enough.
3. Check for Duplicates
Every gh call below targets Kiro Crew's own public repository — a fixed target on
every install, not something resolved from whatever project the user is in. Set it
once; gh accepts a full URL wherever it accepts OWNER/REPO:
REPO=https://github.com/kirodotdev/KiroCrewSearch existing issues to avoid duplicates. Derive plain keywords yourself (a
few alphanumeric words) — do not paste raw user text:
gh issue list --repo "$REPO" \
--search "your derived keywords" --state open --limit 10If you find related issues, show them to the user and ask if any cover their
need. They may want to comment on an existing issue instead.
This search is also your up-front capability check. It is the first gh
call in the flow, so its outcome tells you — before you draft anything —
whether direct submission (Option 3) will work on this host:
- If it succeeds,
ghis installed and authenticated, so Option 3 is available. - If it fails with
command not found,ghis not installed on this host. - If it fails with an auth error,
ghis installed but not authenticated.
In either failure case say so now, before drafting, so the user is not
surprised after approving a draft. Nothing is lost: the flow still drafts the
issue and hands it back as copy/paste text (Option 1), which needs neither gh
nor Browser — only that the user is signed in to GitHub in their own browser to
submit it. Do not silently proceed as if submission will work and only reveal
the gap at the submit step. The duplicate search can still be skipped on failure;
losing it does not block filing.
If the search succeeded, also check whether this account can attach labels.
Run this once:
gh repo view "$REPO" --json viewerPermission -q .viewerPermissionGitHub keeps labels on a new issue only from an account with push access, and
silently drops them for anyone else: gh issue create still succeeds, with no
labels and no error. So labels are allowed only when this prints ADMIN,MAINTAIN or WRITE. Any other answer (TRIAGE, READ, NONE, empty), or a
failed probe, means no labels. Steps 5 and 6 use this result.
4. Draft the Issue
Compose a clean title and markdown body from the conversation. Structure:
## What
[One paragraph describing the feature/bug]
## Why
[Why this matters / what problem it solves]
## Additional Context
[Any extra details, reproduction steps, environment info]Show the draft to the user for confirmation before submitting.
5. Pick Labels From the Repo's Live List
Never hard-code the label vocabulary here. Read it from the repository at
submit time, so labels added later are picked up without editing this skill:
gh label list --repo "$REPO" --limit 100Choose from what that command returns:
- Exactly one type label — the defect label for bug reports, the feature
label for requests. These are mutually exclusive; never apply both. - At most one
area:label and at most oneplatform:label when one
clearly matches — the same two prefixed dimensions the triage classifier may
choose from. No other prefixed dimension is yours to set. Apply an OS label
only when the issue is genuinely specific to that OS — cross-platform issues
get none. - If no value in a dimension fits, leave that dimension off. An unlabeled
dimension is better than a wrong one, and some issues legitimately belong to
no component.
Rules:
- Never create a new label. If the right value does not exist, mention the
gap to the user and submit without it — extending the taxonomy is a maintainer
decision, not a side effect of filing an issue. - Do not apply automation-owned or triage-owned labels — review/readiness
process markers, severity or release-blocking markers, follow-up or
blocked markers, the release-channel labels (channel: *, derived by
triage from the bug form), and the sizing labels (tier:*,pending-triage,triaged) that the issue gate reads to let a PR merge. A freshly filed
request has no way to know those apply, and the workflows that own them will
set them.
If the permission check in step 3 did not allow labels, or never ran, pass no--label flag at all and never tell the user labels will be attached. Tell them
triage will label the issue. You may list the labels you would suggest in the
body under Additional Context; put them in the draft before you show it, or show
the changed draft again before submitting.
Otherwise, collect the chosen names for the submit step below.
If gh is unavailable or unauthenticated, gh label list fails and you cannot
read the taxonomy. Still pick a type label in that case — bug for defects,
enhancement for feature requests, the two that have always existed — and skip
the grouping dimensions, which are the part that grows. Do not guess a grouping
value you could not read. Nothing can attach it on this path, so name it in the
draft and leave the labeling to triage.
6. Submit — Offer the Options
What you can offer depends on the capability check in step 3. If gh worked,
all three options below may apply. If it did not, Option 3 is unavailable on this
host; offer Option 1, and Option 2 only when its query string is short (see
below).
Lead with the routes that reliably reach the user. Crew's chat redacts any
model-written URL whose query string is 200 characters or longer, with no
exception for issue links (this is intentional — injected content could hide
private context in a prefilled body=, and the issue it creates is public). A
prefilled link carrying a drafted title and body almost always crosses that
length and would render as [REDACTED: suspicious URL] rather than a clickable
link, so Option 1 is the primary route and Option 2 is offered only in the rare
short-query case where it survives redaction.
Option 1: Copy/paste (always works, nothing to install)
Show the formatted title and body in a code block the user can copy, and give
them the plain new-issue form link — it has no query string, so it is never
redacted:
https://github.com/kirodotdev/KiroCrew/issues/newThe user pastes the title and body into that form and submits. This needs only
that they are signed in to GitHub in their own browser. You can also point them
at the matching template form — the bug-report form for a defect, the
feature-request form for a request — whose only query parameter is short enough
to survive redaction:
https://github.com/kirodotdev/KiroCrew/issues/new?template=bug_report.yml
https://github.com/kirodotdev/KiroCrew/issues/new?template=feature_request.ymlOption 2: Pre-filled URL (only when its query string is short)
Build a GitHub new-issue URL with query params:
https://github.com/kirodotdev/KiroCrew/issues/new?title=URL_ENCODED_TITLE&body=URL_ENCODED_BODYDo not add a labels= parameter: GitHub answers 404 to a labels query
from anyone without permission to label issues in this repo, which is most
users (chosen labels apply only through Option 3, and only for an account with
WRITE permission or above; triage labels the rest).
Percent-encode the title and body in full, not just their spaces: an
unencoded & starts a new query param and an unencoded # pushes the remainder
into the URL fragment, either of which silently drops the drafted body from the
pre-filled issue.
You build this URL, so you know its length: offer it only when its query
string is under 200 characters (a short title and little or no body). At or
above 200, Crew redacts it in chat as a suspicious URL (intentional, no
exception for issue links), so do not offer it — leave it out silently and use
Option 1 rather than handing the user a link that renders as a[REDACTED: suspicious URL] placeholder. (A URL over ~4000 chars may also be
truncated by GitHub, another reason the short-query case is the only one worth
offering here.)
Option 3: Direct creation via gh CLI (only if the step 3 check succeeded)
On the user's choice, allocate files, then use the file-writing tool to writeBODY_FILE with the confirmed body and TITLE_FILE with the confirmed title,
per Shell safety above:
BODY_FILE=$(mktemp -t kc-issue-body.XXXXXX.md)
TITLE_FILE=$(mktemp -t kc-issue-title.XXXXXX.txt)Then run:
TITLE="$(cat "$TITLE_FILE")"
gh issue create --repo "$REPO" \
--title "$TITLE" \
--body-file "$BODY_FILE" \
--label '<type label>' \
--label '<grouping label, if one was chosen>'Pass one --label flag per name chosen in step 5, each single-quoted. Label
names can contain spaces, and single quotes also keep a $ or backtick in a name
literal — double quotes would let the shell expand it. Omit the extra flags when
no grouping label applies, and pass no --label flag at all when the permission
check in step 3 did not allow labels.
This requires gh auth on the user's machine. If it fails with auth errors,
fall back to Option 1 (copy/paste).
Guidelines
- Keep the conversation light — this isn't a support ticket form
- Two to three exchanges max before drafting
- Always show the draft before submitting
- If the user just wants to vent without filing, that's fine too — acknowledge
and offer to file if they want