Issue Tracer
ZaxbyHub/opencode-swarm
Drives a bug report from validation and root-cause tracing through a critic-reviewed plan, an approved minimal fix and a PR-ready closure, never merging without recorded human approval.
GitHub Issue and PR review thread deep analysis with Codex blind verdict.
Install Issue Analyze
$ npx skills add sd0xdev/sd0x-harness --skill issue-analyze -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install sd0xdev/sd0x-harness issue-analyze --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/sd0xdev/sd0x-harness.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/issue-analyze .claude/skills/issue-analyze && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "issue-analyze" agent skill from https://github.com/sd0xdev/sd0x-harness/tree/main/skills/issue-analyze into .claude/skills/issue-analyze/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "issue-analyze", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/sd0xdev/sd0x-harness/tree/main/skills/issue-analyzeType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add sd0xdev/sd0x-harness --skill issue-analyze -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install sd0xdev/sd0x-harness issue-analyze --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/sd0xdev/sd0x-harness.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/issue-analyze .agents/skills/issue-analyze && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "issue-analyze" agent skill from https://github.com/sd0xdev/sd0x-harness/tree/main/skills/issue-analyze into .agents/skills/issue-analyze/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "issue-analyze", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add sd0xdev/sd0x-harness --skill issue-analyze -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install sd0xdev/sd0x-harness issue-analyze --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/sd0xdev/sd0x-harness.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/issue-analyze .cursor/skills/issue-analyze && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "issue-analyze" agent skill from https://github.com/sd0xdev/sd0x-harness/tree/main/skills/issue-analyze into .cursor/skills/issue-analyze/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "issue-analyze", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/sd0xdev/sd0x-harness.git --path skills/issue-analyze--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add sd0xdev/sd0x-harness --skill issue-analyze -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install sd0xdev/sd0x-harness issue-analyze --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/sd0xdev/sd0x-harness.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/issue-analyze .gemini/skills/issue-analyze && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "issue-analyze" agent skill from https://github.com/sd0xdev/sd0x-harness/tree/main/skills/issue-analyze into .gemini/skills/issue-analyze/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "issue-analyze", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install sd0xdev/sd0x-harness issue-analyzeInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add sd0xdev/sd0x-harness --skill issue-analyze -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/sd0xdev/sd0x-harness.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/issue-analyze .github/skills/issue-analyze && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "issue-analyze" agent skill from https://github.com/sd0xdev/sd0x-harness/tree/main/skills/issue-analyze into .github/skills/issue-analyze/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "issue-analyze", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add sd0xdev/sd0x-harness --skill issue-analyze -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install sd0xdev/sd0x-harness issue-analyze --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/sd0xdev/sd0x-harness.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/issue-analyze .opencode/skills/issue-analyze && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "issue-analyze" agent skill from https://github.com/sd0xdev/sd0x-harness/tree/main/skills/issue-analyze into .opencode/skills/issue-analyze/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "issue-analyze", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Facts
- Skill name
issue-analyze- GitHub stars
- 192
- Token cost
- ~3.4k tokens
- SKILL.md length
- 813 words
- Files
- 3 (incl. references)
- Skills in repo
- 89
- Repo updated
- First seen
- Licence
- MIT
At a glance
GitHub Issue and PR review thread deep analysis with Codex blind verdict.
- : analyzing issue root cause
- SKILL.md covers Trigger, Input Types, Modes and When NOT to Use, plus 8 more sections
- Calls codex and gh
- Classifying problems
What it does
Issue Analyze is an agent skill from sd0xdev/sd0x-harness. GitHub Issue and PR review thread deep analysis with Codex blind verdict. Use when: analyzing issue root cause, classifying problems, investigation planning, triaging PR review comments for actionability. Not for: fixing bugs (use bug-fix), code exploration (use code-explore). Output: classified analysis + verdict assessment + investigation strategy.
Its SKILL.md is about 3.4k tokens, which your agent loads only when the skill is triggered. The skill folder holds 3 other files, including reference files (for example `references/classification.md` and `references/report-template.md`).
It sits in Development, covering Pull requests, Root cause analysis and Debugging. It works with GitHub. The repository describes itself as: The harness layer for Claude Code — a reference implementation of harness engineering with hook-enforced dual review, state-machine gates that survive context compaction, and… The licence is MIT.
When your agent uses it
- : analyzing issue root cause
- Classifying problems
- Investigation planning
- Triaging PR review comments for actionability
Example prompts
- “/issue-analyze”
Requirements
- Pre-approved tools (allowed-tools): Read, Grep, Glob, Bash(git:*), Bash(gh:*), Bash(node:*), Write
What it can do on your machine
Read from SKILL.md and the folder at commit a4d4bc1. It shows what the files ask for, not the result of running them.
Tool permissions
Pre-approves these tools, so the agent can use them without asking each time:
ReadGrepGlobBash(git:*)Bash(gh:*)Bash(node:*)Write
From allowed-tools in the SKILL.md frontmatter.
Runs code
Shell commands in SKILL.md call:
codexgh
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md. Its commands use gh, which can reach the network depending on how they are called.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Context cost
Issue Analyze loads about 3.4k tokens when it runs, and up to ~5.3k if it reads all its reference files. Until then it costs about 92 tokens; SKILL.md has 813 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
Safety
Auto-check passed
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
SKILL.md
The full file from sd0xdev/sd0x-harness at commit a4d4bc1, republished under its MIT licence (© sd0xdev). 813 words, ~3,365 tokens.
Download SKILL.mdSave it as
.claude/skills/issue-analyze/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.- name
- issue-analyze
- description
- GitHub Issue and PR review thread deep analysis with Codex blind verdict. Use when: analyzing issue root cause, classifying problems, investigation planning, triaging PR review comments for actionability. Not for: fixing bugs (use bug-fix), code exploration (use code-explore). Output: classified analysis + verdict assessment + investigation strategy.
- allowed-tools
- Read, Grep, Glob, Bash(git:*), Bash(gh:*), Bash(node:*), Write
Issue Analyze Skill
Trigger
- Keywords: analyze issue, investigate problem, problem analysis, root cause, root cause analysis, triage review, review thread analysis
Input Types
| Type | Source | Example |
|---|---|---|
| GitHub Issue | Issue number, URL, or description | /issue-analyze 123 |
| Review Thread | file:line + reviewer comment | /issue-analyze --triage "src/foo.ts:42 — Use early return" |
When input is a Review Thread:
- Phase 1 skips
gh issue view, uses provided thread data directly - Phase 2 classification uses Review Thread dimensions (see
references/classification.md)
Modes
| Mode | Input Type | Phases Executed | Use Case |
|---|---|---|---|
| Full (default) | Issue or Thread | 1 → 2 → 2.5 → 3 → 4 | Deep analysis with investigation |
Triage (--triage) | Review Thread | 2 → 2.5 only | Lightweight classification + verdict (thread data provided inline) |
Triage (--triage) | GitHub Issue | 1 → 2 → 2.5 | Fetch issue first, then classify + verdict |
When NOT to Use
- Known root cause, fix directly (use
/bug-fix) - Pure feature development (use
/feature-dev) - Only need code review (use
/codex-review)
Workflow
┌─────────────────────────────────────────────────────────────────┐
│ Phase 1: Read Issue / Review Thread │
├─────────────────────────────────────────────────────────────────┤
│ GitHub Issue: gh issue view <number> --json ... │
│ Review Thread: use provided { path, line, reviewer, comment } │
│ Extract: symptoms, reproduction steps, error messages, files │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ Phase 2: Problem Classification │
├─────────────────────────────────────────────────────────────────┤
│ GitHub Issue: Determine problem type → investigation strategy │
│ Review Thread: Determine category → actionability │
│ │
│ ┌────────────────┬──────────────────────────────────┐ │
│ │ Type │ Investigation Strategy │ │
│ ├────────────────┼──────────────────────────────────┤ │
│ │ Unfamiliar │ /code-explore │ │
│ │ Regression │ /git-investigate │ │
│ │ Complex root │ /code-investigate (dual view) │ │
│ │ Multiple cause │ /codex-brainstorm (exhaustive) │ │
│ │ Composite │ Combine multiple strategies │ │
│ └────────────────┴──────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ Phase 2.5: Verdict Assessment (NEW) │
├─────────────────────────────────────────────────────────────────┤
│ Codex blind verification: ACTIONABLE / NON_ACTIONABLE / UNCERTAIN│
│ Fresh exec thread (§ Start), anti-anchoring │
│ Pattern: @skills/seek-verdict/references/verdict-prompt.md │
│ Thresholds: @skills/seek-verdict/references/policy-mapping.md │
│ │
│ ⚠️ Never send Claude's classification to Codex │
│ --triage mode: stop here, output verdict + classification │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ Phase 3: Execute Investigation │
├─────────────────────────────────────────────────────────────────┤
│ Skip if verdict = DISMISS_VERIFIED (per policy-mapping thresholds) │
│ Otherwise: invoke corresponding investigation command │
└─────────────────────────────────────────────────────────────────┘
↓
┌─────────────────────────────────────────────────────────────────┐
│ Phase 4: Consolidated Report │
├─────────────────────────────────────────────────────────────────┤
│ Synthesize investigation results + verdict, produce report │
└─────────────────────────────────────────────────────────────────┘Problem Classification Decision Tree
Issue Symptoms
│
├─ "It used to work, now it doesn't" ───→ /git-investigate
│ (find introduction point)
│
├─ "Don't know how this feature works" ─→ /code-explore
│ (quick understanding)
│
├─ "Has error message / stack trace"
│ │
│ ├─ Clear error ────────────────→ /code-explore
│ │ (trace path)
│ │
│ └─ Vague / intermittent ───────→ /code-investigate
│ (dual-view confirmation)
│
├─ "Many possible causes" ────────────→ /codex-brainstorm
│ (exhaustive analysis)
│
└─ Composite / uncertain ─────────────→ Start with /code-explore
then choose based on resultsInvestigation Tool Comparison
| Tool | Purpose | Speed | Depth |
|---|---|---|---|
/code-explore | Quick code exploration | Fast | Single |
/git-investigate | Track change history | Medium | Single |
/code-investigate | Dual confirmation | Slow | Dual-view |
/codex-brainstorm | Exhaust possibilities | Slowest | Adversarial |
Phase 2.5: Verdict Assessment
After classification, run Codex blind verification to independently assess actionability.
Codex call requirements (same as /seek-verdict pattern):
| Requirement | Detail |
|---|---|
| Thread | Fresh — @skills/codex-code-review/references/codex-transport.md § Start, never a § Resume onto an existing thread |
| Sandbox and approval policy | pinned by the adapter — see @skills/codex-code-review/references/codex-transport.md § Start; not chosen here |
| Anti-anchoring | Never send Claude's Phase 2 classification to Codex |
Prompt construction: follow @skills/seek-verdict/references/verdict-prompt.md pattern, adapting input:
- GitHub Issue input: provide issue title, body, labels as finding context
- Review Thread input: provide file path, line, reviewer comment as finding context
- Always include Standard Research Block (git status, git diff, grep, cat)
Codex output (all fields required):
- codex_verdict: ACTIONABLE | NON_ACTIONABLE | UNCERTAIN
- confidence: [0.0 - 1.0]
- evidence_refs: [files/lines/commands used]
- reasoning: [why this verdict]Policy mapping: follow @skills/seek-verdict/references/policy-mapping.md thresholds (normal state; heightened thresholds apply after [DISMISS_PATTERN_WARN] — see policy-mapping.md Anti-Abuse Guard):
| Verdict | Confidence | Evidence Refs | Result |
|---|---|---|---|
| NON_ACTIONABLE | >= 0.80 (normal) / >= 0.85 (heightened) | >= 2 (normal) / >= 3 (heightened) | Skip Phase 3 investigation (DISMISS_VERIFIED) |
| ACTIONABLE | >= 0.70 | any | Proceed to Phase 3 (FIX_REQUIRED) |
| UNCERTAIN / low | any | any | Proceed to Phase 3 (NEED_HUMAN) |
--triage mode: stop after Phase 2.5, output classification + verdict only.
Graceful degradation — on codex_fail only, which is adapter exit 1 and nothing else
(@skills/codex-code-review/references/codex-transport.md § Completion state machine): log a warning
and continue by mode, because the two modes have different next steps and one instruction cannot
serve both. Full mode proceeds to Phase 3 with the verdict explicitly recorded as unavailable.
--triage mode has no Phase 3 to proceed to — it stops at Phase 2.5 by definition — so it stops
here and emits the classification with verdict: UNAVAILABLE (codex_fail), which the Output and
Verification sections below admit as a complete triage result. Telling triage mode to "proceed to
Phase 3" was an instruction it could not execute. This is a non-gate dispatch, so there is no fallback
carrier to route to. The other outcomes are not this branch: exit 2 is a configuration or
usage error to fix — surface it and stop; an unknown completion is not a failure at all — wait
for it, because a launch is not a verdict. "If the Codex call fails" flattened all three into one
action, which is the reading this line now refuses.
Show full SKILL.md (291 more words)Show less
Output
Full Report (default)
## Issue Analysis: <title>
- **Classification**: <problem type>
- **Verdict**: ACTIONABLE / NON_ACTIONABLE / UNCERTAIN / UNAVAILABLE (codex_fail) (confidence: 0.XX
— omitted for UNAVAILABLE, where no dispatch produced one)
- **Root cause hypothesis**: <analysis>
- **Investigation strategy**: <tools + plan>
- **Priority**: P0 / P1 / P2Triage Report (--triage mode)
## Triage: <file>:<line> (or issue title)
- **Category**: <classification>
- **Verdict**: ACTIONABLE / NON_ACTIONABLE / UNCERTAIN / UNAVAILABLE (codex_fail)
- **Confidence**: 0.XX <!-- omitted when the verdict is UNAVAILABLE: no dispatch produced one -->
- **Reasoning**: <brief justification>
- **Evidence**: <file:line references>UNAVAILABLE (codex_fail) is a complete result in either mode, not a failure to report one: the
classification stands on its own and the verdict line says plainly that no usable Codex verdict was
produced or accepted. That is the accurate claim, and it is narrower than it looks — adapter exit 1
covers failures that happen after the child may have started (a nonzero child exit, a half-written
prompt, malformed JSONL, a missing thread event, an empty report), so codex_fail does not say
whether a reviewer ran. Only exit 2 means nothing was dispatched
(@skills/codex-code-review/references/codex-transport.md § Completion state machine), and exit 2 is
not this branch. Reporting a verdict nobody produced would be the alternative, and it is worse.
Verification
- Issue / review thread content fully extracted
- Problem type correctly classified
- Verdict assessment executed (Codex blind verification) — or the report carries
UNAVAILABLE (codex_fail), which is this item satisfied by the degradation branch rather than unsatisfied: exit 1 can land before any verdict exists to assess - Codex prompt contains no Claude conclusions (anti-anchoring) — applies to the dispatch that was
made; on
codex_failthere may be no completed dispatch to check - Fresh Codex thread used (not reusing existing thread) — same condition
- Investigation strategy reasonably selected (or skipped if NON_ACTIONABLE)
- Report includes root cause analysis + verdict
- Contains specific fix recommendations
-
--triagemode: outputs classification + verdict only — and oncodex_fail, stops there withverdict: UNAVAILABLE (codex_fail)rather than continuing to a phase this mode does not have
References
references/classification.md— Detailed problem classification guide (includes Review Thread dimensions)references/report-template.md— Report template (includes Triage Report)@skills/seek-verdict/references/verdict-prompt.md— Codex blind verification prompt pattern (source of truth)@skills/seek-verdict/references/policy-mapping.md— Verdict thresholds + audit format (source of truth)
Examples
Regression Issue
Input: /issue-analyze 123
Phase 1: gh issue view 123 -> "API returns 500 after update"
Phase 2: Classification = Regression
Phase 3: /git-investigate -> find introducing commit
Phase 4: Report + fix recommendationIntermittent Error
Input: /issue-analyze 456
Phase 1: gh issue view 456 -> "Random timeout occurrences"
Phase 2: Classification = Complex root cause (intermittent)
Phase 3: /code-investigate -> Claude + Codex dual-view
Phase 4: Consolidated report -> ranked possible causesUnknown Feature
Input: /issue-analyze 789
Phase 1: gh issue view 789 -> "Why does it behave this way?"
Phase 2: Classification = Unfamiliar feature
Phase 2.5: Verdict = ACTIONABLE (confidence 0.75) -> proceed
Phase 3: /code-explore -> trace execution path
Phase 4: Report + flow diagram + verdictReview Thread Triage
Input: /issue-analyze --triage "src/service.ts:42 — Use early return instead of nested if"
Phase 2: Classification = nit
Phase 2.5: Verdict = NON_ACTIONABLE (confidence 0.85)
Codex found: current nested pattern follows project convention in 12 other files
Output: Triage report — skip suggested© sd0xdev, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Files
SKILL.md and 2 other files (references) in skills/issue-analyze of sd0xdev/sd0x-harness.
- SKILL.md
- references/classification.md
- references/report-template.md
Open the folder on GitHubat commit a4d4bc1
Compare with similar skills
Issue Analyze next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Issue Analyze this skillsd0xdev/sd0x-harness | 192 | — | ~3.4k | Automated safety check: Pass | MIT | |
| Issue TracerZaxbyHub/opencode-swarm | 490 | — | ~4.4k | Automated safety check: Pass | MIT | |
| Bugfix PRTanStack/ai | 3.2k | — | ~4.8k | Automated safety check: Pass | MIT | |
| Exposed Bug Fix WorkflowJetBrains/Exposed | 9.3k | — | ~3.8k | Automated safety check: Pass | Apache-2.0 | |
| OpenROAD Bug FixerThe-OpenROAD-Project/OpenROAD | 3.2k | — | ~784 | Automated safety check: Pass | BSD-3-Clause | |
| Octocode Code Researchbgauryy/octocode | 949 | — | ~1.5k | Automated safety check: Pass | MIT |
Similar skills
Bugfix PR
TanStack/ai
Treats bug-fix pull requests as invasive and untrusted. An agent skill from TanStack/ai.
- Official
Exposed Bug Fix Workflow
JetBrains/Exposed
Takes a GitHub or YouTrack issue for the Exposed project through reproduction, a failing test, a fix, validation and a pull request.
OpenROAD Bug Fixer
The-OpenROAD-Project/OpenROAD
Fixes an OpenROAD bug from a GitHub issue or error code: finds the root cause, implements the fix, adds a regression test and prepares a signed-off commit.
Octocode Code Research
bgauryy/octocode
Researches code with evidence: traces callers, imports and cross-repo links, diagnoses failures and reports findings with exact file and line references and a confidence label.
- Official
Triagebot Action Bug Triage
withastro/astro
Takes a bug report for the triagebot-action GitHub Action through reproduction, root-cause diagnosis, an intended-behavior check and a fix attempt.
More from sd0xdev/sd0x-harness
All 89 skills in this repoAdr
sd0xdev/sd0x-harness
Write an Architecture Decision Record (ADR) for a feature — Context / Decision / Status / Consequences / Alternatives, filed as docs/features/<feature/adr-<NNN-<title.md with a 3-digit zero-padded…
Load PR Review
sd0xdev/sd0x-harness
Load GitHub PR review comments into AI session — analyze, triage, plan.
Next Step
sd0xdev/sd0x-harness
Change-aware next step advisor. An agent skill from sd0xdev/sd0x-harness.
Obsidian CLI
sd0xdev/sd0x-harness
Obsidian vault integration via official CLI. An agent skill from sd0xdev/sd0x-harness.
Orchestrate
sd0xdev/sd0x-harness
Agent-driven workflow orchestration (v1 report-only). An agent skill from sd0xdev/sd0x-harness.
PR Comment
sd0xdev/sd0x-harness
Post friendly review comments to a GitHub PR — prepare locally, preview, then submit as atomic review.
Related
Works with
Categories
Questions about Issue Analyze
What does Issue Analyze do?
GitHub Issue and PR review thread deep analysis with Codex blind verdict. Issue Analyze is an agent skill from sd0xdev/sd0x-harness. GitHub Issue and PR review thread deep analysis with Codex blind verdict.
When should I use Issue Analyze?
Issue Analyze fits situations like: : analyzing issue root cause; classifying problems; investigation planning; triaging PR review comments for actionability.
How do I install Issue Analyze in Claude Code?
Run `npx skills add sd0xdev/sd0x-harness --skill issue-analyze -a claude-code`. Or copy the skill folder (skills/issue-analyze in sd0xdev/sd0x-harness) into .claude/skills/issue-analyze in your project. Claude Code loads it when a task matches its description.
How do I install Issue Analyze in Codex?
Run `npx skills add sd0xdev/sd0x-harness --skill issue-analyze -a codex`. Or copy the skill folder (skills/issue-analyze in sd0xdev/sd0x-harness) into .agents/skills/issue-analyze in your project. Codex loads it when a task matches its description.
Can I use Issue Analyze in Cursor, Gemini CLI or GitHub Copilot?
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add sd0xdev/sd0x-harness --skill issue-analyze -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/issue-analyze, .gemini/skills/issue-analyze, .github/skills/issue-analyze and .opencode/skills/issue-analyze in your project.
What does Issue Analyze need to run?
Going by SKILL.md and its folder, Issue Analyze needs the command-line tools its instructions call (codex and gh). Its frontmatter pre-approves these tools: Read, Grep, Glob, Bash(git:*), Bash(gh:*), Bash(node:*), Write.
Does Issue Analyze access the network?
SKILL.md contains no URLs. Its commands use gh, which can reach the network depending on how they are called. This is read from the text; nothing was executed.
Is Issue Analyze safe to install?
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
What licence does Issue Analyze use?
Issue Analyze is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
How many tokens does Issue Analyze use?
About 3.4k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.9k tokens, read only when the agent opens those files.
What are the alternatives to Issue Analyze?
Skills that share tags, products or a category with Issue Analyze: Issue Tracer (ZaxbyHub/opencode-swarm, 490 stars), Bugfix PR (TanStack/ai, 3.2k stars), Exposed Bug Fix Workflow (JetBrains/Exposed, 9.3k stars) and OpenROAD Bug Fixer (The-OpenROAD-Project/OpenROAD, 3.2k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Issue Analyze?
sd0xdev (a GitHub user) maintains it in sd0xdev/sd0x-harness, which has 192 GitHub stars. The repository holds 89 skills in this directory. The repository was last updated on October 8, 2026.
Source: sd0xdev/sd0x-harness on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.