agentleFS
KenosIncKenosInc/sigrok-mcp-server/.claude/skills/issue-manager/SKILL.md

issue-manager

Skill12 starsChanged 9 months agoMITView on GitHub

A skill for creating and updating GitHub Issues. Used during the planning phase of feature development to structure Issues with summary, background, implementation approach, impact scope, and Definition of Done. Trigger when the user says things like "create an issue", "write an issue", "make a plan", "summarize the requirements", or "make a ticket", or as the first step of feature development. Also handles updating existing Issues (requirement changes, DoD additions, scope changes, etc.). Includes partial updates by issue number, such as "update Issue #XX" or "add … to Issue #XX". Use this skill proactively whenever the user asks to write, structure, or plan Issue content. Do NOT use for simple operations like closing Issues, changing labels, or assigning, nor for code implementation, fixes, or reviews.

3 other projects use a version of this.

Adopted by

Most recently taken up by

  • Other versions3 projects use a version of this.

    Word for word · 0

    None found.

    Edited · 0

    None found.

    Wrote their own version · 3

    1. icetomoyo/CodingSkills★ 4same name
    2. fworks-tech/agenthood★ 2same name
    3. alexchen5/research-epic-manager★ 0same name

    How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.

  • In this repositoryOne other file it gives its agents.

The file

We split this skill into the rules it gives an agent

10 rules. About 0 are common, 7 are distinctive, and 3 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈7

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 3

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    When investigating, refer to the project's package structure:

    line 35
  2. Distinctive:

    When updating an existing Issue, maintain the same section structure from the template.

    line 46
  3. Distinctive:

    Summary: Keep it brief. Technical terms are fine, but make it immediately clear what will be done

    line 87
  4. Distinctive:

    Implementation Approach: Write concretely based on the codebase investigation.

    line 89
  5. Very specific:

    Use table-driven tests with t.Run() subtests following the project convention.

    line 95
  6. Distinctive:

    Keep the title concise and descriptive of what will be done

    line 106
  7. Very specific:

    Add labels with --label if applicable

    line 107
  8. Very specific:

    Before updating, review the current content with gh issue view <number>

    line 115
  9. Distinctive:

    Leave a comment explaining the reason for the change to preserve context

    line 117
  10. Distinctive:

    After creating or updating, present the Issue URL to the user.

    line 125

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

GitHub Issue Manager

A skill for creating and updating GitHub Issues. Organizes development plans into a structured format within Issues.

Workflow

1. Gather Information

Understand the following from the user's request. Investigate the codebase to fill in any gaps.

  • What needs to be achieved
  • Why it is needed (background / motivation)
  • Preliminary technical approach
  • Completion criteria

2. Codebase Investigation

Investigate related code to accurately describe the implementation approach and impact scope.

  • Identify the components and files to be changed
  • Review existing implementation patterns
  • Enumerate existing features that may be affected

When investigating, refer to the project's package structure:

  • cmd/sigrok-mcp-server/ — Entrypoint (thin wiring, no tests needed)
  • internal/tools/ — MCP tool handlers; uses Runner interface for mock injection
  • internal/sigrok/ — CLI executor and parsers; uses CommandFactory test seam and testdata/ golden files
  • internal/serial/ — Serial port communication; uses PortOpener seam
  • internal/devices/ — Device profile registry with embedded JSON
  • internal/config/ — Env-based configuration

3. Issue Body Structure

Compose the body following the template below. All sections should be included. When updating an existing Issue, maintain the same section structure from the template.

## Summary

<!-- What will be done. 1-2 sentences, concise. -->

## Background & Motivation

<!-- Why this is needed. User-experience issues, technical problems, etc. -->

## Implementation Approach

<!-- Technical approach. Files, components, and steps to change. -->

## Impact Scope

<!-- Scope of changes, effects on existing features, caveats. -->

## Test Strategy

<!-- Describe the testing approach:
  - Which test seams to use (Runner mock, CommandFactory, PortOpener, etc.)
  - Table-driven test cases to cover
  - Corner cases and boundary conditions
  - Error and exception scenarios (invalid input, timeouts, non-zero exit codes)
  - Silent failure scenarios (nil dependencies, empty output, missing fields)
-->

## DoD (Definition of Done)

- [ ] Completion criterion 1
- [ ] Completion criterion 2
- [ ] Tests cover the happy path
- [ ] Tests cover corner cases and error scenarios
- [ ] No silent failures (errors are surfaced, not swallowed)
- [ ] CI passes

Template Usage Guidelines

  • Summary: Keep it brief. Technical terms are fine, but make it immediately clear what will be done
  • Background & Motivation: Serves as the basis for implementation decisions. A clear "why" prevents scope drift
  • Implementation Approach: Write concretely based on the codebase investigation. Include file paths and component names
  • Impact Scope: Important for preventing breakage of existing features. Explicitly stating "no impact" is also valuable
  • Test Strategy: Describe the testing approach concretely. List test seams to use (e.g. Runner mock, CommandFactory, PortOpener). Enumerate corner cases, boundary conditions, error scenarios (invalid input, timeouts, non-zero exit), and silent failure scenarios (nil dependencies, empty output, fallback behavior). Use table-driven tests with t.Run() subtests following the project convention.
  • DoD: Checklist format. Always include tests and CI passing. Add review criteria as needed

4. Creating / Updating Issues

New Issue

gh issue create --title "<title>" --body "<body>"
  • Keep the title concise and descriptive of what will be done
  • Add labels with --label if applicable

Updating an Existing Issue

gh issue edit <number> --body "<body>"
  • Before updating, review the current content with gh issue view <number>
  • Restructure the existing content to match the template sections and add new requirements. Fill in any missing sections (Background & Motivation, Impact Scope, etc.)
  • Leave a comment explaining the reason for the change to preserve context
gh issue comment <number> --body "Requirement change: ..."

5. Confirmation

After creating or updating, present the Issue URL to the user.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.