home / skills / google-gemini / gemini-cli / github-issue-creator

github-issue-creator skill

/.gemini/skills/github-issue-creator

This skill creates GitHub issues using repository templates, applies correct labeling, and formats content for reliable, consistent issue tracking.

npx playbooks add skill google-gemini/gemini-cli --skill github-issue-creator

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.9 KB
---
name: github-issue-creator
description:
  Use this skill when asked to create a GitHub issue. It handles different issue
  types (bug, feature, etc.) using repository templates and ensures proper
  labeling.
---

# GitHub Issue Creator

This skill guides the creation of high-quality GitHub issues that adhere to the
repository's standards and use the appropriate templates.

## Workflow

Follow these steps to create a GitHub issue:

1.  **Identify Issue Type**: Determine if the request is a bug report, feature
    request, or other category.

2.  **Locate Template**: Search for issue templates in
    `.github/ISSUE_TEMPLATE/`.
    - `bug_report.yml`
    - `feature_request.yml`
    - `website_issue.yml`
    - If no relevant YAML template is found, look for `.md` templates in the same
      directory.

3.  **Read Template**: Read the content of the identified template file to
    understand the required fields.

4.  **Draft Content**: Draft the issue title and body/fields.
    - If using a YAML template (form), prepare values for each `id` defined in
      the template.
    - If using a Markdown template, follow its structure exactly.
    - **Default Label**: Always include the `🔒 maintainer only` label unless the
      user explicitly requests otherwise.

5.  **Create Issue**: Use the `gh` CLI to create the issue.
    - **CRITICAL:** To avoid shell escaping and formatting issues with
      multi-line Markdown or complex text, ALWAYS write the description/body to
      a temporary file first.

    **For Markdown Templates or Simple Body:**
    ```bash
    # 1. Write the drafted content to a temporary file
    # 2. Create the issue using the --body-file flag
    gh issue create --title "Succinct title" --body-file <temp_file_path> --label "🔒 maintainer only"
    # 3. Remove the temporary file
    rm <temp_file_path>
    ```

    **For YAML Templates (Forms):**
    While `gh issue create` supports `--body-file`, YAML forms usually expect
    key-value pairs via flags if you want to bypass the interactive prompt.
    However, the most reliable non-interactive way to ensure formatting is
    preserved for long text fields is to use the `--body` or `--body-file` if the
    form has been converted to a standard body, OR to use the `--field` flags
    for YAML forms.

    *Note: For the `gemini-cli` repository which uses YAML forms, you can often
    submit the content as a single body if a specific field-based submission is
    not required by the automation.*

6.  **Verify**: Confirm the issue was created successfully and provide the link
    to the user.

## Principles

- **Clarity**: Titles should be descriptive and follow project conventions.
- **Defensive Formatting**: Always use temporary files with `--body-file` to
  prevent newline and special character issues.
- **Maintainer Priority**: Default to internal/maintainer labels to keep the
  backlog organized.
- **Completeness**: Provide all requested information (e.g., version info,
  reproduction steps).

Overview

This skill creates high-quality GitHub issues that follow a repository's templates and labeling conventions. It detects the issue type (bug, feature, etc.), reads the appropriate template, drafts title and body content, and uses the GitHub CLI to create the issue. The skill ensures defensive formatting and applies a default maintainer-only label unless the user opts out.

How this skill works

The skill inspects the repository for issue templates in .github/ISSUE_TEMPLATE/ (YAML or Markdown) and reads required fields or structure. It determines the issue category, fills form fields or composes a Markdown body, and writes the content to a temporary file to avoid shell escaping problems. It then invokes gh issue create with --body-file (and --field flags for YAML forms when needed), applies default labels, verifies creation, and returns the issue link to the user.

When to use it

  • When asked to open a bug report, feature request, or website issue in a repository.
  • When the repository uses issue templates and you want to follow required fields exactly.
  • When you need consistent labels applied (defaulting to maintainer-only).
  • When the issue contains complex or multi-line content that could break CLI commands.

Best practices

  • Always search .github/ISSUE_TEMPLATE/ for YAML or Markdown templates before drafting an issue.
  • Write the issue body to a temporary file and use gh issue create --body-file to avoid escaping problems.
  • Populate each template field by id for YAML forms, or follow Markdown template structure exactly.
  • Include version, reproduction steps, and expected vs actual behavior for bug reports.
  • Default to the "🔒 maintainer only" label unless the user explicitly requests public visibility.

Example use cases

  • Create a bug report using bug_report.yml, filling required form fields and attaching reproduction steps.
  • Submit a feature request using feature_request.yml, composing a clear title, motivation, and acceptance criteria.
  • Open a website issue using a Markdown template, preserving the template structure in the body file.
  • Create a general issue when no template exists, still writing the body to a temp file and applying the default maintainer label.

FAQ

What if the repository has no issue templates?

Draft a concise title and structured body including environment, steps to reproduce, and expected behavior. Write the body to a temporary file and use gh issue create with the default maintainer label.

How do you handle YAML form templates non-interactively?

Prefer using --field flags for individual fields when supported. If fields include long text, convert to a single body or use --body-file to preserve formatting; verify the repository accepts non-interactive submissions first.