Skip to content
Skills Library
Programming · Building & coding

implement

/implement

This skill should be used when the user asks to "implement an issue", "create a PR for issue", "implement issue #123", "turn this issue into code", or wants to implement a GitHub issue following an implementation plan and create a pull request.

Licence
MIT
Last repository change
16.07.2026

Assessment and security

84/ 100Class: good
Format9 / 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
1
Scripts
0
HTML comments
0
URLs in SKILL.md
1
Deprecation

No signals detected. Repository changed on 16.07.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

This skill should be used when the user asks to "implement an issue", "create a PR for issue", "implement issue #123", "turn this issue into code", or wants to implement a GitHub issue following an implementation plan and create a pull request.

Triggers from the description

implement an issuecreate a PR for issueimplement issue #123turn this issue into code

Arguments

/implement <issue-number>
Original author description

This skill should be used when the user asks to "implement an issue", "create a PR for issue", "implement issue #123", "turn this issue into code", or wants to implement a GitHub issue following an implementation plan and create a pull request.

How it works

  1. Workflow Overview
  2. Step 1: Fetch Issue Details
  3. Step 2: Create Feature Branch
  4. Step 3: Implement Changes
  5. Step 4: Create Pull Request
  6. Step 5: Comment on Issue
  7. Step 6: Add Label
  8. Error Handling
  9. Important Guidelines
  10. Completion Summary
Original SKILL.md headings · 185 lines, 745 words
SKILL.md preview
---
description: This skill should be used when the user asks to "implement an issue", "create a PR for issue", "implement issue #123", "turn this issue into code", or wants to implement a GitHub issue following an implementation plan and create a pull request.
argument-hint: "<issue-number>"
disable-model-invocation: true
allowed-tools: Bash, Read, Write, Edit, Grep, Glob, WebFetch
---

# GitHub Issue Implementer

Implement a GitHub issue by reading the implementation plan from the issue (description, comments, and replies), writing the code, creating a pull request, and updating the issue status.

## Workflow Overview

1. Fetch issue details and implementation plan from GitHub
2. Create a feature branch
3. Implement the changes based on the plan
4. Create a pull request
5. Comment on the issue with PR link
6. Add label to indicate implementation is in progress

## Step 1: Fetch Issue Details

Retrieve comprehensive issue information:

```bash
gh issue view $ARGUMENTS --json number,title,body,comments,labels
```

Parse the response to extract:
- Issue number and title
- Implementation plan from the body
- Additional requirements or clarifications from comments
- Existing labels for context

If the issue has comments, read all comments to find implementation plans or additional requirements:

```bash
gh issue view $ARGUMENTS --comments
```

Look for implementation plan sections typically marked with headers like "Implementation Plan", "Approach", or "Steps".

## Step 2: Create Feature Branch

Create and checkout a new branch for the implementation:

```bash
git checkout -b issue-$ARGUMENTS
```

If the branch already exists, confirm with the user before proceeding.

## Step 3: Implement Changes

Based on the implementation plan extracted from the issue:

1. **Analyze the plan**: Identify all files to create or modify
2. **Follow the steps**: Implement each step in the plan sequentially
3. **Write tests**: Include unit tests as specified in the plan
4. **Follow codebase patterns**: Match existing code style and conventions

During implementation:
- Read relevant existing files to understand patterns
- Use Grep and Glob to find related code
- Make incremental changes, verifying each step works

If the plan is unclear or incomplete:
- Ask the user for clarification before proceeding
- Document assumptions made during implementation

## Step 4: Create Pull Request

After implementation is complete, create a pull request:

```bash
gh pr create --title "Implement #$ARGUMENTS: <issue-title>" --body "$(cat <<EOF
## Summary

Implements #$ARGUMENTS

<Brief description of changes>

## Changes Made

- <List of key changes>

## Testing

- <How the changes were tested>

## Related Issue

Closes #$ARGUMENTS

---
*PR generated with [Claude Code](https://claude.ai/code) - github-devflow:implement*
EOF
)"
```

Link the PR to the issue using "Closes #N" or "Fixes #N" syntax.

## Step 5: Comment on Issue

Add a comment to the original issue linking to the PR:

```bash
gh issue comment $ARGUMENTS --body "Implementation PR created: <pr-url>

The implementation follows the plan outlined in this issue. Please review the PR for details."
```

## Step 6: Add Label

Add the `implementation-started` label to indicate work is in progress:

```bash
gh issue edit $ARGUMENTS --add-label "implementation-started"
```

If the label doesn't exist, create it first:

```bash
gh label create "implementation-started" --description "Implementation work has started" --color "FFA500"
```

## Error Handling

### Authentication Issues

If `gh` CLI is not authenticated:
```
Error: gh CLI requires authentication. Run 'gh auth login' first.
```

### Missing Implementation Plan

If no clear implementation plan is found in the issue:
- Inform the user that no implementation plan was found
- Suggest using the `github-issue-planner` plugin first to create a plan
- Ask if the user wants to proceed with their own implementation approach

### Merge Conflicts

If there are conflicts with the base branch:
- Report the conflicts to the user
- Offer to help resolve them or wait for user decision

### Label Creation Fails

If unable to create the label (permissions issue):
- Continue without labeling
- Inform the user that the label could not be added

## Important Guidelines

### Code Quality

- Follow existing code patterns and conventions
- Write clean, readable code
- Include appropriate comments where logic is non-obvious
- Handle edge cases mentioned in the plan

### Commits

- Make atomic commits for logical changes
- Write clear commit messages that reference the issue number
- Do not commit generated files or secrets

### Testing

- Run existing tests to ensure no regressions
- Add tests as specified in the implementation plan
- If no tests are specified, add reasonable test coverage

### Communication

- Report progress at each major step
- Ask for clarification when requirements are ambiguous
- Summarize what was implemented when complete

## Completion Summary

After successful completion, provide a summary:

- PR URL and number
- List of files changed
- Tests added or modified
- Any deviations from the original plan
- Next steps (code review, CI checks, etc.)

Versions

RepositoryScoreLicence
This page · hhiroshell/gh-devflow-plugins84MIT
ericrisco/rsc-harness100MIT
yonatangross/orchestkit100MIT
sentimony/agentic-workflow100MIT
moberghr/mtk-agent-toolkit100MIT
michielvandermeer/skills100MIT
rossumai/claude-marketplace100MIT
userKael/rastro100MIT
yonatangross/orchestkit100MIT

Database snapshot: 13.11.2026 · package version 857320227df9 (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

  • 100implement-issue
    Read a GitHub issue, create a branch, implement the solution, and open a PR. Use when given an issue number to implement.
  • 100implement-issue
    Turn one labelled GitHub issue into one reviewed pull request, or stop with a stated reason. Use for every factory run; the message is a link to the issue.
  • 100dev-issue
    Implements GitHub issues end-to-end. Use to turn an issue into a merge-ready PR.
  • 100implement-issue
    Implement a julianpalomo.dev GitHub issue end to end. Reads it with gh, creates its branch, posts the plan on the issue and waits for an OK, implements, runs /handoff and /ship-pr, then acts on the PR's review. Use when asked to implement, build or work on an issue by number.
  • 100dx-implement-issue
    Use when someone wants an existing GitHub issue built, for example "implement issue 142", "pick up this issue", "build the story in issue 98", or when they paste an issue body and ask for the code. Reads the issue, checks it is specific enough to build, plans against its…
  • 100gh-issue-resolver
    Implement and verify a fix for a GitHub Issue whose response plan has already been posted as a comment by gh-issue-planner. Creates a feature branch, applies the agreed plan, runs tests, and opens a Pull Request. Use when the user asks to implement/fix/resolve a planned GitHub…

Feedback and reports

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