ss-agile-implementing-an-issue

Implement a GitHub issue on a checked-out feature branch with commits and verification.

Updated May 19, 2026
One-click install
npx skills add https://github.com/Emrebener/Sublime-Skills --skill ss-agile-implementing-an-issue
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: ss-agile-implementing-an-issue
Source: https://github.com/Emrebener/Sublime-Skills/tree/main/skills/agile-ralph-loop/ss-agile-implementing-an-issue
Command: npx skills add https://github.com/Emrebener/Sublime-Skills --skill ss-agile-implementing-an-issue

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill removes uncertainty and coordination overhead for implementing a single GitHub issue by defining a clear, autonomous workflow for a subagent that must deliver a correct, merge-ready change on an already-prepared feature branch.

Core Features & Use Cases

  • Issue-to-change execution: Implements exactly the provided issue body and acceptance criteria on the current branch without changing scope.
  • Autonomy without questions: Operates under a strict contract to never ask for decisions that require a human response, instead making conservative choices and reporting assumptions.
  • Verification and clean-tree safety: Runs relevant tests and enforces a clean git status --porcelain state, including handling generated outputs via committing or updating .gitignore.
  • Structured coordinator reporting: Produces a single parseable report detailing status, commits, acceptance-criterion evidence, test results, and any non-obvious notes.

Quick Start

Use ss-agile-implementing-an-issue when dispatched by the coordinator to implement the specified issue on the current feature branch and return a structured completion report.

Frequently Asked Questions about ss-agile-implementing-an-issue

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement a single GitHub issue autonomously without scope creep?

To implement a single GitHub issue autonomously, you translate the issue body and acceptance criteria into code changes and commits on an already-checked-out branch. This enforces strict scope control by making conservative choices and reporting assumptions in a structured coordinator report.

How do I verify code changes against acceptance criteria before committing?

Verifying code changes against acceptance criteria requires running relevant tests and checking each criterion individually during implementation. The process enforces a clean `git status --porcelain` state by committing generated outputs or updating `.gitignore`.

Can a subagent implement GitHub issues and open pull requests automatically?

A subagent implementing GitHub issues can write code and create commits, but it must not pick issues, open pull requests, or merge. It operates within a pipeline to deliver merge-ready changes and returns a structured completion report instead.

What's the best way to handle untracked files when finishing an issue implementation?

Handling untracked files when finishing issue implementation requires enforcing a clean git tree with `git status --porcelain`. You must either commit generated outputs or update `.gitignore` to ensure no stray files remain before reporting completion.

How does autonomous subagent coordination work for issue implementation?

Autonomous subagent coordination for issue implementation works by operating under a strict contract to never ask questions requiring human response. The subagent makes conservative decisions, implements the issue, verifies acceptance criteria, and outputs a parseable report with status, commits, and test results.

Why does my automated issue implementation leave a dirty git tree?

Automated issue implementation leaves a dirty git tree when generated outputs are not properly committed or ignored. Enforcing a clean `git status --porcelain` state requires committing build artifacts or updating `.gitignore` before returning the completion report.