A skill that uses subagents to tackle issues in parallel with code review gates between batches, enabling systematic handling of multiple related issues across platforms.

When should I avoid using do-issue?

If there is only a single simple fix, or the issue requires clarification—comment first to clarify scope.

Which platforms does it support and how?

It automatically detects GitHub, GitLab, or Bitbucket via leyline:git-platform and uses the appropriate CLI (gh for GitHub, glab for GitLab) for interactions.

do-issue

workflow-automation

npx machina-cli add skill athola/claude-night-market/do-issue --openclaw

Files (1)

SKILL.md

5.5 KB

Key Features
Workflow Overview
Required TodoWrite Items
Configuration
Detailed Resources

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
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
2. Planning	Analyze dependencies, create task breakdown	task-planning
3. Execution	Dispatch parallel subagents for independent tasks	parallel-execution
4. Quality	Code review gates between task batches	quality-gates
5-6. Completion	Sequential tasks, final review, issue updates	completion

Required TodoWrite Items

do-issue:discovery-complete
do-issue:tasks-planned
do-issue:parallel-batch-complete
do-issue:review-passed
do-issue:sequential-complete
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.

# 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

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 for input parsing and requirement extraction
Phase 2: See modules/task-planning.md for dependency analysis
Phase 3: See modules/parallel-execution.md for subagent dispatch
Phase 4: See modules/quality-gates.md for review patterns
Phase 5-6: See modules/completion.md for finalization
Errors: See modules/troubleshooting.md for common issues

Source

git clone https://github.com/athola/claude-night-market/blob/master/plugins/sanctum/skills/do-issue/SKILL.mdView on GitHub

Overview

do-issue automates addressing GitHub, GitLab, or Bitbucket issues by splitting work into subagents that run tasks in parallel. It enforces code review gates between batches and ensures each subagent starts with a clean context. Use it when multiple related issues need systematic, parallel progress rather than a single direct fix.

How This Skill Works

The skill automatically detects the platform via leyline:git-platform, retrieves issue content, and creates a plan that distributes work to subagents. Subagents execute independent tasks in parallel, with code-review gates enforced between batches to maintain quality. After all batches complete, the workflow performs sequential steps and updates the issue accordingly.

When to Use It

You have multiple related issues that can be split into independent tasks.
You need parallel execution of tasks with quality gates between batches.
Work spans GitHub, GitLab, or Bitbucket and platform detection is beneficial.
You want a structured lifecycle from discovery to completion with reviews between stages.
Each subagent should start with a fresh context to avoid cross-task contamination.

Quick Start

Step 1: Discover issues and extract requirements using issue-discovery, then plan with task-planning.
Step 2: Dispatch parallel subagents for independent tasks via parallel-execution and enforce quality gates between batches.
Step 3: Complete sequential tasks, perform final review, and update the issue status to done.

Best Practices

Define discovery and requirements completion before planning to prevent scope creep.
Keep task batches small enough to maximize safe parallelism without introducing dependencies.
Enforce code review gates between batches to preserve quality and prevent regression.
Use the Forge CLI commands appropriate to the detected platform (gh for GitHub, glab for GitLab).
Track progress with required TodoWrite items and perform a thorough final update to the issue.

Example Use Cases

Coordinating fixes for three related issues in a single project by splitting work into parallel subagents and reviewing results between batches.
Addressing a cross-platform cleanup that spans GitHub and GitLab repos by assigning independent tasks to subagents with gates between batches.
A large backlog requiring discovery, planning, and parallel execution across modules before a final review.
Refactoring multiple components across repositories, using subagents to implement changes in parallel with quality gates.
Updating API usage across repositories in parallel, ensuring each batch passes a code review before proceeding.

Frequently Asked Questions

Add this skill to your agents