Agent skill

Opsmill Dev Analyzing Bugs

by opsmill in opsmill/infrahub

Performs root-cause analysis of a bug — from a GitHub issue, an issue URL, or a free-text description — before any reproduction or fix is written.

Apache-2.0Auto-check passedDevelopment

Install Opsmill Dev Analyzing Bugs

skills CLI
$ npx skills add opsmill/infrahub --skill opsmill-dev-analyzing-bugs -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install opsmill/infrahub opsmill-dev-analyzing-bugs --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/opsmill/infrahub.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/opsmill-dev-analyzing-bugs .claude/skills/opsmill-dev-analyzing-bugs && rm -rf skills-src

Use ~/.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/

Facts

Skill name
opsmill-dev-analyzing-bugs
GitHub stars
529
Token cost
~2.3k tokens
SKILL.md length
889 words
Files
1
Skills in repo
32
Repo updated
First seen
Licence
Apache-2.0

At a glance

Performs root-cause analysis of a bug — from a GitHub issue, an issue URL, or a free-text description — before any reproduction or fix is written.

  • Works in 4 steps: Read root AGENTS.md and… → Read the relevant source files in the… → Identify the most likely root cause(s)… → …
  • Diagnosing a bug
  • SKILL.md covers User Input, Your role, Tool usage and Input, plus 5 more sections
  • Calls git and gh; reaches github.com

What it does

Opsmill Dev Analyzing Bugs is an agent skill from opsmill/infrahub. Performs root-cause analysis of a bug — from a GitHub issue, an issue URL, or a free-text description — before any reproduction or fix is written. TRIGGER when: triaging or diagnosing a bug, investigating why something misbehaves, an issue number/URL handed over for analysis, needing the root cause before touching code. DO NOT TRIGGER when: a failing reproduction test already exists and you are ready to fix → opsmill-dev-fixing-bugs; writing that reproduction test → opsmill-dev-test-driving-bugs; capturing a new…

Its SKILL.md is about 2.3k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts. Compatibility notes: Works in any git repo; anchors discovery on the OpsMill dev/ layout with codebase fallback. gh is optional, used only for issue numbers/URLs.

It sits in Development, covering Root cause analysis. It works with GitHub and Bash. The repository describes itself as: Infrahub is a graph-based data management platform with built-in version control, CI workflows, peer review, and API access. It’s purpose-built to power reliable infrastructure… The licence is Apache-2.0.

When your agent uses it

  • Diagnosing a bug
  • Investigating why something misbehaves
  • An issue number/URL handed over for analysis
  • Needing the root cause before touching code

Example prompts

  • “Use the opsmill-dev-analyzing-bugs skill to perform root-cause analysis of a bug — from a GitHub issue, an issue URL, or a free-text description —…”
  • “/opsmill-dev-analyzing-bugs”

Requirements

  • Compatibility (from SKILL.md): Works in any git repo; anchors discovery on the OpsMill `dev/` layout with codebase fallback. `gh` is optional, used only for issue numbers/URLs.

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. Read root AGENTS.md and dev/documentation-architecture.md (if present) to determine which
  2. Read the relevant source files in the affected area to understand the current behavior.
  3. Identify the most likely root cause(s) -- point to specific files and lines.
  4. Formulate a fix strategy. This is NOT the exact code -- it is the recommended approach

What it can do on your machine

Read from SKILL.md and the folder at commit af1c6c8. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git
    • gh

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • github.com

    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.

  • Compatibility

    Works in any git repo; anchors discovery on the OpsMill `dev/` layout with codebase fallback. `gh` is optional, used only for issue numbers/URLs.

    From compatibility in the SKILL.md frontmatter.

Context cost

Opsmill Dev Analyzing Bugs loads about 2.3k tokens when it runs. Until then it costs about 148 tokens; SKILL.md has 889 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~148
When it runs · the whole SKILL.md, loaded when a task matches
~2.3k

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 opsmill/infrahub at commit af1c6c8, republished under its Apache-2.0 licence (© opsmill). 889 words, ~2,280 tokens.

Download SKILL.mdSave it as .claude/skills/opsmill-dev-analyzing-bugs/SKILL.md (or your agent's skills folder).
name
opsmill-dev-analyzing-bugs
description
Performs root-cause analysis of a bug — from a GitHub issue, an issue URL, or a free-text description — before any reproduction or fix is written. TRIGGER when: triaging or diagnosing a bug, investigating why something misbehaves, an issue number/URL handed over for analysis, needing the root cause before touching code. DO NOT TRIGGER when: a failing reproduction test already exists and you are ready to fix → opsmill-dev-fixing-bugs; writing that reproduction test → opsmill-dev-test-driving-bugs; capturing a new bug as a ticket → opsmill-dev-creating-issues.
compatibility
Works in any git repo; anchors discovery on the OpsMill `dev/` layout with codebase fallback. `gh` is optional, used only for issue numbers/URLs.
argument-hint
<issue number or URL, or a free-text bug description>
metadata.pipeline
bug-fixing (1 of 3 — analyze → test-drive → fix)
metadata.version
0.1.0
metadata.author
OpsMill
user-invocable
true

Bug analyst

User Input

text
$ARGUMENTS

Your role

You are a senior engineer performing root cause analysis. You do NOT write fixes or tests. Your output will be consumed by /opsmill-dev-test-driving-bugs and /opsmill-dev-fixing-bugs, so be structured and precise.

Tool usage

  • Use the Read tool to read files -- do NOT use cat or head/tail in Bash.
  • Use the Glob tool to find files -- do NOT use find or ls -R in Bash.
  • Use the Grep tool to search file contents -- do NOT use grep or rg in Bash.
  • Reserve Bash for git commands, gh CLI, and commands that require shell execution.
  • Shell state does not persist across separate Bash calls (variables, cd); re-derive or restate anything you need in a later snippet.

Input

Parse $ARGUMENTS to determine what you are analysing:

  • Issue number or URL (e.g. 4872 or https://github.com/org/repo/issues/4872): extract the issue number. If gh is available, fetch the issue:

    bash
    gh issue view <number>
  • Free-text description: treat the text itself as the bug report.

Derive a key for this analysis (used to name the handoff file and downstream branch/PR):

  • If an issue number is present, <key> = <issue_number>-<short-slug>.
  • Otherwise <key> = <short-slug> only.

The <short-slug> is a lowercase, hyphenated 2--5 word summary of the bug (e.g. internal-groups-dropdown). Always include the slug so concurrent analyses never collide.

This <key> is invented here (the slug is free-form), so it is the canonical one for the whole pipeline. You will persist it -- and the downstream branch name ai-bug-pipeline-<key> -- into the handoff file below, so /opsmill-dev-test-driving-bugs and /opsmill-dev-fixing-bugs read them instead of re-deriving a slug that could drift (e.g. internal-groups-dropdown vs groups-dropdown-internal).

If $ARGUMENTS is empty or an issue cannot be fetched, inform the developer and STOP.

Discover project context (read what exists, skip what doesn't)

Anchor on the common OpsMill dev/ structure; fall back to exploration when it is absent. None of these files are required.

FileIf present, use it for
root AGENTS.mdProject map, working agreements, where code lives.
dev/documentation-architecture.mdMapping the bug to the relevant code package(s).
dev/knowledge/Descriptive architecture — how the affected area actually works.
dev/guidelines/Prescriptive rules for the affected area.

Investigation

Follow these sections in order.

Issue clarity check

Verify the report has enough information to work with:

RequiredDescription
Clear problem statementCan you understand what the bug actually is?
Reproduction pathAre there steps to reproduce, OR can you infer them from the description?
Expected vs actualIs it clear what should happen vs what happens?

Rate the clarity:

  • CLEAR: intent, reproduction scenario, and expected behavior are understandable (even if some details like the affected release are missing).
  • UNCLEAR: the intent and reproduction scenario are not understandable.

If the bug is UNCLEAR, inform the developer what information is missing and STOP.

Show full SKILL.md (442 more words)Show less
Investigate the codebase
  1. Read root AGENTS.md and dev/documentation-architecture.md (if present) to determine which code package(s) relate to the issue. Then:

    • If you can determine the related code package, rate code identification as RESOLVED.
    • If you cannot, rate it EXPLORATION REQUIRED and explore the codebase (use Glob/Grep) until you locate the affected area.
  2. Read the relevant source files in the affected area to understand the current behavior.

  3. Identify the most likely root cause(s) -- point to specific files and lines.

    • If you cannot identify a root cause after exploration, inform the developer and STOP.
  4. Formulate a fix strategy. This is NOT the exact code -- it is the recommended approach:

    • Approach: What should the fixer do and where? Reference existing functions/methods that should be reused rather than reimplemented.
    • Scope: Which files/functions need changes? How large should the change be?
    • Do NOT: List common wrong approaches (e.g., adding a guard clause when the real fix is a missing validation, creating new abstractions when an existing one should be reused).

Output

Determine the repository's default branch and fetch its latest state, to record what the analysis is based on:

bash
DEFAULT_BRANCH=$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@')
# Fallback when origin/HEAD is unset (shallow/CI clones, manually-added remotes):
[ -z "$DEFAULT_BRANCH" ] && DEFAULT_BRANCH=$(git remote show origin 2>/dev/null | sed -n 's/.*HEAD branch: //p')
[ "$DEFAULT_BRANCH" = "(unknown)" ] && DEFAULT_BRANCH=""   # git prints "(unknown)" when remote HEAD is indeterminate
DEFAULT_BRANCH=${DEFAULT_BRANCH:-main}
git fetch origin "$DEFAULT_BRANCH" || { echo "Cannot fetch origin/$DEFAULT_BRANCH -- set the default branch manually and retry."; exit 1; }
git rev-parse "origin/$DEFAULT_BRANCH"

If that fetch fails, STOP and report it -- do not write the analysis without a baseline commit (the exit 1 only fails the shell call; you must not continue to the next section).

Write the analysis to .bug-analysis-<key>.md in the repo root using the template below. This file is a local working-tree artifact, not committed -- add .bug-analysis-*.md to the repo's .gitignore if it is not already ignored, and never git add it.

Then display the full analysis to the developer in the conversation.

Analysis template

Replace all <placeholders>:

markdown
## Root cause analysis for <key>

**Key:** `<key>`
**Branch:** `ai-bug-pipeline-<key>`
**Issue:** <issue title or one-line restatement of the description>
**Based on:** `<commit SHA of origin/<default branch>>`
**Bug clarity:** CLEAR
**Code identification:** RESOLVED | EXPLORATION REQUIRED

### Root cause

<one-sentence summary>

### Affected files

- `path/to/file.ext` -- line X: <why this is the culprit>

### Explanation

<detailed reasoning>

## Fix strategy

**Approach:** <recommended fix approach -- explain WHAT to do and WHERE, not the exact code>

**Scope:** <which files/functions should need changes, and roughly how large the change should be>

**Do NOT:**

- <guardrail 1 -- common wrong approach to avoid>
- <guardrail 2 -- unnecessary refactoring to avoid>

## Notes for downstream steps

<edge cases, risks, or constraints the test-writer and fixer should know about>

Quality gates

Per ../quality-gates/gates/gate-model.md. analyzing-bugs is Tier 0 (advisory output).

GateTriggerTierPrimitivesPass criteriaOn-fail
Grounded-analysisbefore writing the analysis fileT0P1 + self-reviewEvery root-cause claim cites a concrete file:line.revise before writing

Common mistakes

🚩 Red flagDo instead
Writing fix code (or a test) into the analysisThis step does analysis only — describe the fix strategy, not the patch; /opsmill-dev-test-driving-bugs and /opsmill-dev-fixing-bugs do the rest
Analysing an UNCLEAR bug or one with no findable root causeSTOP and tell the developer what's missing — a confident-sounding analysis of an unclear bug misleads both later steps
Re-deriving or guessing a slug later in the pipelineInvent the <key> once here and persist it (and ai-bug-pipeline-<key>) in the handoff header so /opsmill-dev-test-driving-bugs / /opsmill-dev-fixing-bugs read it instead of drifting
Writing the analysis without a baseline commitIf the default-branch fetch fails, STOP — the **Based on:** SHA is what later steps reproduce against
git add-ing the .bug-analysis-*.md fileIt is a local working-tree artifact — never commit it

© opsmill, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .agents/skills/opsmill-dev-analyzing-bugs of opsmill/infrahub.

Open the folder on GitHubat commit af1c6c8

Compare with similar skills

Opsmill Dev Analyzing Bugs 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.

Opsmill Dev Analyzing Bugs compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Opsmill Dev Analyzing Bugs this skillopsmill/infrahub529—~2.3kAutomated safety check: PassApache-2.0
OpenROAD Bug FixerThe-OpenROAD-Project/OpenROAD3.2k—~784Automated safety check: PassBSD-3-Clause
Octocode Code Researchbgauryy/octocode946—~1.5kAutomated safety check: PassMIT
CI TriageMentra-Community/MentraOS2.4k—~582Automated safety check: PassApache-2.0
Triagebot Action Bug Triagewithastro/astro63k—~639Automated safety check: PassCustom licence
Stereopy Issue ResponderSTOmics/Stereopy293—~1.3kAutomated safety check: PassMIT

Similar skills

  • 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.

    3.2k GitHub stars~784 tokensUpdated yesterday
    DevelopmentAuto-check passed
  • 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.

    946 GitHub stars~1.5k tokensUpdated 4 days ago
    DevelopmentAuto-check passed
  • CI Triage

    Mentra-Community/MentraOS

    Triage failing GitHub PR checks: list failures with gh, fetch capped Actions logs, skip non-Actions checks, and summarize root cause.

    2.4k GitHub stars~582 tokensUpdated today
    DevelopmentAuto-check passed
  • Official

    Takes a bug report for the triagebot-action GitHub Action through reproduction, root-cause diagnosis, an intended-behavior check and a fix attempt.

    63k GitHub stars~639 tokensUpdated today
    DevelopmentAuto-check passed
  • Stereopy Issue Responder

    STOmics/Stereopy

    Generates professional maintainer-grade responses for Stereopy GitHub issues.

    293 GitHub stars~1.3k tokensUpdated 2 mo ago
    DevelopmentAuto-check passed
  • Reviewing Pull Requests

    Shopify/shopify-app-js

    Official

    Reviews pull requests for Shopify/shopify-app-js with comprehensive analysis including semver compliance (MAJOR/MINOR/PATCH classification), single responsibility validation, pattern consistency…

    543 GitHub stars~1.9k tokensUpdated 5 days ago
    DevelopmentAuto-check passed

More from opsmill/infrahub

All 32 skills in this repo
  • Analyzing CI Flakiness

    opsmill/infrahub

    Analyzes recent CI failures on pull requests to identify flaky tests, using retry outcomes (failed attempt → green re-run) and cross-PR recurrence as evidence, and maintains a local longitudinal…

    529 GitHub stars~2k tokensUpdated today
    Auto-check passed
  • Audit Docs

    opsmill/infrahub

    Audits internal (dev/) and external (docs/) documentation completeness for a feature, subject, or set of existing docs, maps changes indicated by the user, across Infrahub's documentation layers…

    529 GitHub stars~1.5k tokensUpdated today
    Auto-check passed
  • Commit

    opsmill/infrahub

    Stages and commits the current changes onto a safe working branch, enforcing branch discipline and optionally pushing upstream.

    529 GitHub stars~2.8k tokensUpdated today
    Auto-check: notes
  • A skill your agent uses when you've fixed a bug, added a feature, or made any user-facing change in a project that uses Towncrier and need to record it for the changelog — before committing or…

    529 GitHub stars~1.9k tokensUpdated today
    Auto-check passed
  • Creating Issues

    opsmill/infrahub

    Turns a single feature idea, improvement, or bug into ONE well-structured GitHub issue.

    529 GitHub stars~1.2k tokensUpdated today
    Auto-check passed
  • Creating Prd

    opsmill/infrahub

    Synthesises the current conversation context into a Product Requirements Document and publishes it to GitHub (as a comment on a referenced issue, or a new issue).

    529 GitHub stars~4k tokensUpdated today
    Auto-check passed

Works with

Categories

Questions about Opsmill Dev Analyzing Bugs

What does Opsmill Dev Analyzing Bugs do?

Performs root-cause analysis of a bug — from a GitHub issue, an issue URL, or a free-text description — before any reproduction or fix is written. Opsmill Dev Analyzing Bugs is an agent skill from opsmill/infrahub. Performs root-cause analysis of a bug — from a GitHub issue, an issue URL, or a free-text description — before any reproduction or fix is written.

When should I use Opsmill Dev Analyzing Bugs?

Opsmill Dev Analyzing Bugs fits situations like: diagnosing a bug; investigating why something misbehaves; an issue number/URL handed over for analysis; needing the root cause before touching code.

How do I install Opsmill Dev Analyzing Bugs in Claude Code?

Run `npx skills add opsmill/infrahub --skill opsmill-dev-analyzing-bugs -a claude-code`. Or copy the skill folder (.agents/skills/opsmill-dev-analyzing-bugs in opsmill/infrahub) into .claude/skills/opsmill-dev-analyzing-bugs in your project. Claude Code loads it when a task matches its description.

How do I install Opsmill Dev Analyzing Bugs in Codex?

Run `npx skills add opsmill/infrahub --skill opsmill-dev-analyzing-bugs -a codex`. Or copy the skill folder (.agents/skills/opsmill-dev-analyzing-bugs in opsmill/infrahub) into .agents/skills/opsmill-dev-analyzing-bugs in your project. Codex loads it when a task matches its description.

Can I use Opsmill Dev Analyzing Bugs 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 opsmill/infrahub --skill opsmill-dev-analyzing-bugs -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/opsmill-dev-analyzing-bugs, .gemini/skills/opsmill-dev-analyzing-bugs, .github/skills/opsmill-dev-analyzing-bugs and .opencode/skills/opsmill-dev-analyzing-bugs in your project.

What does Opsmill Dev Analyzing Bugs need to run?

Going by SKILL.md and its folder, Opsmill Dev Analyzing Bugs needs the command-line tools its instructions call (git and gh). Compatibility (from SKILL.md): Works in any git repo; anchors discovery on the OpsMill `dev/` layout with codebase fallback. `gh` is optional, used only for issue numbers/URLs..

Does Opsmill Dev Analyzing Bugs access the network?

SKILL.md names 1 domain. In commands or code: github.com; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Opsmill Dev Analyzing Bugs 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 Opsmill Dev Analyzing Bugs use?

Opsmill Dev Analyzing Bugs is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Opsmill Dev Analyzing Bugs use?

About 2.3k tokens (SKILL.md is roughly 9.1k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Opsmill Dev Analyzing Bugs?

Skills that share tags, products or a category with Opsmill Dev Analyzing Bugs: OpenROAD Bug Fixer (The-OpenROAD-Project/OpenROAD, 3.2k stars), Octocode Code Research (bgauryy/octocode, 946 stars), CI Triage (Mentra-Community/MentraOS, 2.4k stars) and Triagebot Action Bug Triage (withastro/astro, 63k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Opsmill Dev Analyzing Bugs?

opsmill (a GitHub organization) maintains it in opsmill/infrahub, which has 529 GitHub stars. The repository holds 32 skills in this directory. The repository was last updated on October 7, 2026.

Source: opsmill/infrahub on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.