Skip to content
OpenAgentSkill
Browsing is open · Catalog captured 2026-11-21 · Automatic updates and account services are paused.
Development

vigilante-create-issue

Help a human author write an implementation-ready GitHub issue that Vigilante can execute reliably.

aliengiraffe · AI review on file

Installation

Read the source and dependencies before running a command. Copying does not install or execute anything.

npx skills add aliengiraffe/vigilante --skill vigilante-create-issue

About this skill


name: vigilante-create-issue description: Help a human author write an implementation-ready GitHub issue that Vigilante can execute reliably.

Vigilante Create Issue

Overview

Use this skill when a human wants to write or refine a GitHub issue that Vigilante will later implement. The default goal is to turn a vague request into an issue with enough behavioral detail, constraints, and verification criteria for a headless coding agent to execute safely, then create that issue on GitHub. If creation is not possible, fall back to returning a ready-to-file issue body. The goal is not to design the full solution for them.

Outcome

Produce a GitHub issue that is:

  • classified as a feature, bug, or task before the draft is finalized
  • specific about the problem and why it matters
  • grounded in repository or product context
  • explicit about expected behavior and non-goals
  • realistic about implementation flexibility and hard constraints
  • testable through concrete acceptance criteria
  • clear about validation and regression coverage
  • created on GitHub by default when the target repository can be resolved and gh issue creation is available
  • returned as a polished Markdown draft only when the user explicitly asks for draft-only output or issue creation is blocked

Workflow

  1. Clarify the request before writing
  • Identify the change the user actually wants.
  • Ask for missing repository, product, or user context when it affects implementation.
  • Separate required behavior from guesses or preferences.
  1. Classify the request before finalizing the issue body
  • Decide whether the request is best treated as a feature, bug, or task.
  • Base the classification on the user's stated problem and desired outcome rather than implementation details.
  • If the request is ambiguous, infer the most likely type and state briefly that the type was inferred.
  • Use the selected type to decide which details are required in the issue body, not just to append a label.
  1. Resolve the target repository before finalizing output
  • Prefer local git context first when the user is working inside a repository.
  • Otherwise use an explicitly provided repository slug or URL.
  • If the repository cannot be resolved confidently, say so briefly and fall back to returning the ready-to-file issue body instead of guessing.
  1. Frame the issue around execution
  • Write for the agent that will implement the issue later, not for a broad brainstorming audience.
  • Prefer observable behavior over vague aspirations.
  • Note any constraints that must be preserved: CLI flags, APIs, config compatibility, UX expectations, rollout limits, or performance boundaries.
  1. Capture implementation guidance without over-constraining
  • Include likely solution paths when they materially reduce ambiguity.
  • Mark which implementation details are required and which are flexible.
  • Call out known tradeoffs or rejected alternatives when relevant.
  1. Make completion testable
  • Convert expectations into pass/fail acceptance criteria.
  • State what tests should be added or updated.
  • Mention the key regressions or failure modes that must be prevented.
  1. Create the GitHub issue by default
  • When the repository is known and the user did not explicitly ask for draft-only output, use vigilante gh issue create to open the issue.
  • Prefer vigilante gh api repos/{owner}/{repo}/issues over vigilante gh issue create when opening the final issue so Vigilante can set GitHub's native issue type with the request body type field.
  • Map Vigilante's internal classifications explicitly to GitHub's native issue types: feature -> Feature, bug -> Bug, task -> Task.
  • Treat the native GitHub issue type as the source of truth whenever the repository supports it.
  • When the draft explicitly says the new issue is a follow-up, child, or sub-issue of a specific existing issue, carry that parent issue number through issue creation.
  • After the base issue is created, attach it as a native GitHub sub-issue of that parent with vigilante gh api --method POST repos/{owner}/{repo}/issues/{parent_issue_number}/sub_issues -f sub_issue_id={created_issue_id}.
  • Only create a native relationship when the parent mapping is explicit and low-ambiguity; incidental issue-number mentions in prose are not enough.
  • If native sub-issue creation fails or the repository does not support it, keep the created issue, preserve the body text reference, and make the fallback explicit in the final response.
  • Use the polished Markdown body as the issue content instead of stopping at the draft.
  • In the final response, include the created issue URL or issue number and keep the body available if useful.
  1. Fall back cleanly when issue creation is blocked
  • If issue creation cannot be completed because repository context is missing, gh auth is unavailable, network access is blocked, or sandbox restrictions prevent GitHub access, say so briefly and return the ready-to-file Markdown issue instead.
  • If the repository rejects the native type field because issue types are unavailable or unsupported, retry issue creation without the native type and make the fallback explicit in the final response.
  • If the native sub-issue relationship request is rejected or unsupported, do not fail the overall issue creation flow; keep the new issue and report that the relationship fell back to body-only text.
  • If the environment supports requesting escalation for GitHub/network access, do that before giving up.
  • If the user explicitly asks for a draft only, honor that request and do not create the issue.
  • Keep failure messaging short, specific, and factual.

Issue Type Guidance

  • Always classify the request as feature, bug, or task before finalizing the issue.
  • When creating the issue on GitHub, write that classification into GitHub's native issue type field whenever the repository supports it.
  • Do not use labels or issue-body text as the primary type representation whe
Read the complete source ↗