Skip to content
Skills Library
Programming · Automation

do-issue

/do-issue

Implements GitHub or GitLab issues via parallel subagents with review gates between task batches. Use when resolving multi-step issues end-to-end.

Licence
MIT
Last repository change
01.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
7
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 01.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Implements GitHub or GitLab issues via parallel subagents with review gates between task batches. Use when resolving multi-step issues end-to-end.

Original author description

Implements GitHub or GitLab issues via parallel subagents with review gates between task batches. Use when resolving multi-step issues end-to-end.

How it works

  1. When NOT To Use
  2. Key Features
  3. Workflow Overview
  4. Required TodoWrite Items
  5. Forge CLI Commands
  6. Agent Teams (Default Execution Mode)
  7. Configuration
  8. Detailed Resources
  9. Exit Criteria
Original SKILL.md headings · 108 lines, 642 words
SKILL.md preview
---
name: do-issue
role: entrypoint
description: Implements GitHub or GitLab issues via parallel subagents with review gates between task batches. Use when resolving multi-step issues end-to-end.
alwaysApply: false
category: workflow-automation
tags:
- github
- gitlab
- issues
- subagents
- parallel
- automation
- cross-platform
dependencies:
- leyline:git-platform
- superpowers:subagent-driven-development
- superpowers:writing-plans
- superpowers:test-driven-development
- superpowers:requesting-code-review
- superpowers:finishing-a-development-branch
tools: []
usage_patterns:
- issue-discovery
- task-planning
- parallel-execution
- quality-gates
complexity: advanced
model_hint: deep
estimated_tokens: 2500
modules:
- modules/issue-discovery.md
- modules/task-planning.md
- modules/parallel-execution.md
- modules/quality-gates.md
- modules/completion.md
- modules/troubleshooting.md
---

## When NOT To Use

- A single-file fix obvious enough to make directly
- Preparing the PR once the work is done (use `sanctum:pr-prep`)

# Fix Issue(s)

Retrieves issue content from the detected git platform (GitHub, GitLab, or Bitbucket) and uses subagent-driven-development to systematically address requirements, executing tasks in parallel where dependencies allow.

**Platform detection is automatic** via the `leyline:git-platform` SessionStart hook. Check session context for `git_platform:` to determine which CLI to use.

## Key Features

- **Cross-Platform**: Automatically detects GitHub/GitLab/Bitbucket and uses appropriate CLI
- **Flexible Input**: Single issue number, platform URL, or space-delimited list
- **Parallel Execution**: Independent tasks run concurrently via subagents
- **One PR**: All issues produce one consolidated PR (never per-issue PRs)
- **Quality Gates**: Code review between task groups
- **Fresh Context**: Each subagent starts with clean context for focused work

## Workflow Overview

| Phase | Description | Module |
|-------|-------------|--------|
| 1. Discovery | Parse input, fetch issues, extract requirements | [issue-discovery](modules/issue-discovery.md) |
| 2. Planning | Analyze dependencies, create task breakdown | [task-planning](modules/task-planning.md) |
| 3. Execution | Dispatch parallel subagents for independent tasks | [parallel-execution](modules/parallel-execution.md) |
| 4. Quality | Code review gates between task batches | [quality-gates](modules/quality-gates.md) |
| 5-6. Completion | Sequential tasks, final review, issue updates | [completion](modules/completion.md) |

## Required TodoWrite Items

1. `do-issue:discovery-complete`
2. `do-issue:tasks-planned`
3. `do-issue:parallel-batch-complete`
4. `do-issue:review-passed`
5. `do-issue:sequential-complete`
6. `do-issue:issues-updated`

## Forge CLI Commands

Use the platform detected in session context (`git_platform:`). See `Skill(leyline:git-platform)` for full mapping.

| Operation | GitHub (`gh`) | GitLab (`glab`) |
|-----------|---------------|-----------------|
| Fetch issue | `gh issue view <N> --json title,body,labels,comments` | `glab issue view <N>` |
| Comment | `gh issue comment <N> --body "msg"` | `glab issue note <N> --message "msg"` |
| Close | `gh issue close <N> --comment "reason"` | `glab issue close <N>` |
| Search | `gh issue list --search "query"` | `glab issue list --search "query"` |

**Verification:** Run the command with `--help` flag to verify availability.

## Agent Teams (Default Execution Mode)

Agent teams is the **default** parallel execution backend for do-issue. Teammates coordinate via filesystem-based messaging, enabling real-time communication when shared files or dependencies are discovered mid-implementation.

**Automatic downgrade**: For single issues with `--scope minor`, agent teams is skipped (Task tool or inline execution is used instead). Use `--no-agent-teams` to force Task tool dispatch for any invocation.

**Requires**: Claude Code 2.1.32+, tmux, `CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1`. If prerequisites are missing, silently falls back to Task tool dispatch.

```yaml
# Agent teams configuration
fix_issue:
  agent_teams:
    enabled: true           # on by default; --no-agent-teams to disable
    max_teammates: 4        # limit concurrent workers
    model: sonnet           # teammate model (lead uses current model)
    auto_downgrade: true    # skip agent teams for --scope minor
```

See `modules/parallel-execution.md` for detailed agent teams patterns.

## Configuration

```yaml
fix_issue:
  parallel_execution: true
  max_parallel_subagents: 3
  review_between_batches: true
  auto_close_issues: false
  commit_per_task: true
```
**Verification:** Run the command with `--help` flag to verify availability.

## Detailed Resources

- **Phase 1**: See [modules/issue-discovery.md](modules/issue-discovery.md) for input parsing and requirement extraction
- **Phase 2**: See [modules/task-planning.md](modules/task-planning.md) for dependency analysis
- **Phase 3**: See [modules/parallel-execution.md](modules/parallel-execution.md) for subagent dispatch
- **Phase 4**: See [modules/quality-gates.md](modules/quality-gates.md) for review patterns
- **Phase 5-6**: See [modules/completion.md](modules/completion.md) for finalization
- **Errors**: See [modules/troubleshooting.md](modules/troubleshooting.md) for common issues

## Exit Criteria

- [ ] All 6 required TodoWrite items (`do-issue:discovery-complete`
      through `do-issue:issues-updated`) are created before execution
      starts and each marked complete when its phase finishes
- [ ] Issue requirements fetched using the correct forge CLI (`gh` for
      GitHub, `glab` for GitLab) as detected in session context
- [ ] Exactly one consolidated PR is opened covering all issues; no
      per-issue PRs are created
- [ ] Code review gate runs between parallel task batches and must
      pass before the next batch is dispatched
- [ ] All specified issues are commented on or closed with a reference
      to the PR after it is ready for review
Files in this package (7)
  • SKILL.md 6 KB
  • modules/completion.md 4 KB
  • modules/issue-discovery.md 2 KB
  • modules/parallel-execution.md 12 KB
  • modules/quality-gates.md 1 KB
  • modules/task-planning.md 2 KB
  • modules/troubleshooting.md 3 KB

Versions

The database has no other skills named do-issue.

Database snapshot: 13.11.2026 · package version 180d07f0e21f (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100git-issue
    GitHub issue to PR end-to-end — branch, TDD implementation, PR — one issue or several in parallel. Use when asked to work on an issue, fix issue #N, or batch-process several.
  • 100issue-creation
    Generate issues following repository templates for GitHub or GitLab. Use when creating bug reports, feature requests, or other issues. Triggers: "create issue", "bug report", "feature request", "new issue".
  • 100dev-issue
    Implements GitHub issues end-to-end. Use to turn an issue into a merge-ready PR.
  • 100github-fix-issue
    Fix GitHub issues end-to-end — analysis, branch creation, implementation, testing, and PR submission. Use whenever the user mentions fixing a GitHub issue, says "fix issue #123", "work on this issue", "修复 issue", or references a GitHub issue number or URL.
  • 90github-issues
    Use when filing a bug, requesting a feature, creating an issue, or updating issue details. Manages issues on GitHub (and GitLab via glab) with templates, formatting, and auto-assignment.
  • 100gitlab
    GitLab issues, merge requests, repositories, CI pipelines, and code search via the glab CLI. Use when the user mentions GitLab, an MR/issue number, a project on gitlab.com, or a self-hosted GitLab instance.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.