# Issue

> Use when {{USER}} invokes /issue with a GitHub issue number, or asks to start, implement, resume, or publish one GitHub issue end to end in a local repository. Owns a single ready issue from readiness checks through a reviewable pull request, stopping for the green hand before any Git publication.

- Skill: `sarveshcore/issue` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add sarveshcore/issue`
- Raw SKILL.md: https://api.skillmd.com/api/skills/sarveshcore/issue/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: sarveshcore (https://skillmd.com/u/sarveshcore)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/sarveshcore/issue

---


# Implement GitHub Issue

## Overview

Own one ready GitHub issue from evidence gathering through a reviewable pull request. Remove routine
reminders while retaining readiness, TDD, verification, and human publication gates.

## Required workflow

Read [references/workflow.md](references/workflow.md) completely before acting. That file is the shared
workflow body, symlinked to the same definition the Codex `$issue` skill uses, so both runtimes stay in
step. This SKILL.md carries only the Claude Code specifics.

Treat the repository's `AGENTS.md`, current code/tests/Git state, and committed decisions as higher
authority than this skill.

Extract exactly one issue number or URL from the invocation. If none is present, ask one concise
question and stop.

## Delegation

Use the `issue-reader` agent for read-only exploration and independent review. Dispatch it with the
Agent tool and let its definition supply the model; it is pinned to `haiku` per the global model-routing
rule for read-only investigation. Do not override that to a premium model for a routine scan.

Send parallel `issue-reader` dispatches in a single message so they run concurrently. Cap discovery at
two agents, per the workflow's economy rule.

If `issue-reader` is unavailable, do not silently substitute a premium read-only agent. Perform the read
in the main session, state the limitation once, and continue.

Delegate implementation only when independent write scopes genuinely justify the coordination overhead.
Verification stays in the main session; the one exception is the mandatory independent adversarial
review, which must run in a context that did not implement the change.

**Enforcement limitation, state it rather than assume it away:** Codex pins `issue-reader` to a
read-only sandbox. Claude Code has no per-agent sandbox, so `issue-reader` is constrained by its tool
list and its instructions, plus the global `bash-guard` PreToolUse hook. Treat read-only as a contract
the agent is instructed to honor, not one the runtime enforces.

## Claude Code process skills

The workflow calls for the repository-required brainstorming, TDD, and debugging workflows. In Claude
Code those are:

- `superpowers:brainstorming` before design work on anything creative or new;
- `superpowers:test-driven-development` before any production code;
- `superpowers:systematic-debugging` before proposing any fix for unexpected behavior;
- `superpowers:verification-before-completion` before claiming the slice is done.

Invoke them through the Skill tool. They are gates, not suggestions.

## Hard boundaries

- One issue, one branch, one PR.
- Do not implement blocked, unready, ambiguous, or dependency-gated work.
- Do not merge, force-push, push feature work to `main`, expose secrets, or widen external authority.
- Do not stage private brain content or unrelated user changes.
- Stop before Git publication until {{USER}} says `green hand`.
- In this workflow, `green hand` authorizes scoped commit, feature-branch push, ready PR creation, and
  the exhaustive issue comment as one sequence. It authorizes nothing beyond that sequence.
- Add `Closes #N`; let Sage's merge close the issue. Do not close it while the PR is open.

## Completion output

Lead with the outcome. Give the branch, commit, PR, issue comment, CI state, external cleanup state,
and the single next human action.