Preface¶

After finishing code changes and running tests, there’s often a fixed sequence of actions: git add, git commit, git push, then opening a browser or terminal to use gh pr create to fill in the title and description. The steps themselves aren’t difficult, but in AI-assisted programming scenarios, after the Agent finishes modifying the files, you still have to dictate “Help me commit and open a PR”. Missing any step, writing too vague a PR description, or accidentally creating a duplicate PR when one already exists on the branch will interrupt your workflow.

yeet is an Agent Skill maintained by OpenAI in the .curated directory of the openai/skills repository. The name comes from an internet slang (roughly meaning “to throw something forcefully”), but its functionality is highly practical: when you explicitly request the full Git release process, the Agent will follow the steps outlined in SKILL.md, using GitHub CLI (gh) to sequentially stage, commit, push, and create or update a Pull Request. It follows the standard SKILL.md format, and can be used in tools that support Agent Skills such as Codex, Cursor, and Claude Code.

What is yeet?¶

The positioning of yeet can be summarized in one sentence:

Only when the user explicitly requests it, use GitHub CLI (gh) to complete stage, commit, push and open a GitHub Pull Request in one go.

Source and attribution:
- Maintainer: OpenAI, included in the official skill directory skills/.curated/yeet
- Official address: https://github.com/openai/skills/tree/main/skills/.curated/yeet
- License: Apache License 2.0 (see LICENSE.txt in the directory)
- Format: Standard SKILL.md, with YAML frontmatter (name, description) and Markdown body instructions

It should be noted that the homepage of the openai/skills repository has been marked as deprecated, and the subsequent Codex plugin system will be migrated to openai/plugins; however, the original SKILL.md of yeet is still accessible, and ecosystems such as JetBrains also have mirrored references to the Skill with the same name. This article takes the official curated version from OpenAI as the reference.

Core Features and Highlights¶

According to the official SKILL.md, the capabilities covered by yeet can be divided into several sections:

1. Full Git Release Pipeline¶

The Agent will execute in order:
1. Confirm the current branch; if on main / master or the repository’s default branch, first create a new branch with git checkout -b "{description}"
2. Check the status with git status -sb, then stage all changes with git add -A
3. Commit with a short description using git commit -m "{description}"
4. Run project checks if they haven’t been executed yet; if the check fails due to missing dependencies, install the dependencies and retry once
5. Push and set the upstream with git push -u origin $(git branch --show-current)
6. Use gh to create or update a PR, and correct the title and body

2. Smart PR Template Awareness¶

In May 2026, OpenAI made an important update to yeet (commit 590b49e), giving it template awareness and branch awareness. Before creating a PR, the Agent will look for templates in the repository root directory in priority order:
- .github/pull_request_template.md
- .github/PULL_REQUEST_TEMPLATE.md
- *.md under .github/pull_request_template/
- *.md under .github/PULL_REQUEST_TEMPLATE/

If a unique template is found, it will be read and applied via gh pr create --template; if multiple templates exist, it will pause and ask the user which one to select; if no template is found, the built-in fallback structure of the Skill (Why / What Changed) will be used.

3. Avoid Duplicate PRs and Preserve Review Status¶

After pushing, it will check if there is already a PR for the current branch:

gh pr view "$(git branch --show-current)" --json number,isDraft,url

Existing PR: Update the title and description in place, will not create another one, and will not change the draft / ready-for-review status of the existing PR
No existing PR: Create a draft PR (--draft), and edit the title and body later

This is very useful for scenarios where you push multiple times to the same feature branch and iterate continuously.

4. Standardized PR Title and Body¶

The Skill embeds Conventional Commits-style PR title guidelines, for example:

feat: add hat wobble
^--^  ^------------^
|     |
|     +-> Summary in present tense
|
+-------> Type: chore, docs, feat, fix, refactor, style, test

The PR body emphasizes writing Why (motivation and impact) first, followed by What Changed (net changes). If the repository template requires a Verification section, fill it in only when you have real behavioral evidence, and avoid using vague content like “ran lint / tests passed” as filler.

5. Memorable Name, Low Threshold¶

Compared to Skills that require understanding of MCP, browser automation, or deployment platforms, yeet only depends on git and gh — almost every GitHub developer has these installed locally. The name is memorable, and the trigger method is clear (see notes below), making it a Skill that you will want to try right after installing it.

Prerequisites¶

Before yeet starts, the Skill requires the Agent to verify two things first:

1. GitHub CLI is installed

gh --version

If it is not installed, prompt the user to install GitHub CLI and stop execution.

2. gh authentication is completed

gh auth status

If not logged in, prompt to run gh auth login and recheck the status.

In addition, the current directory must be a Git repository, and the remote must point to GitHub (the PR process depends on gh).

Installation and Activation¶

In OpenAI Codex¶

According to the openai/skills README, curated skills can be installed by name via the built-in installer:

$skill-installer yeet

You can also specify the GitHub directory URL:

$skill-installer install https://github.com/openai/skills/tree/main/skills/.curated/yeet

After installation, you need to restart Codex to load the new Skill. System skills in the .system directory will be installed automatically in the latest version of Codex; curated skills need to be installed manually.

In Cursor¶

Cursor will automatically discover Skills from the following paths (both project-level and global):
| Path | Scope |
|------|--------|
| .cursor/skills/ | Project-level, can be committed to the repository and shared with the team |
| ~/.cursor/skills/ | User-level, available across projects |
| .agents/skills/ | Project-level, universal for multiple Agent tools |

Steps to manually install yeet:

mkdir -p .cursor/skills/yeet
curl -L -o .cursor/skills/yeet/SKILL.md \
  https://raw.githubusercontent.com/openai/skills/main/skills/.curated/yeet/SKILL.md

The directory name yeet must match name: "yeet" in the SKILL.md frontmatter. After saving, restart Cursor or reopen the workspace, and the Agent will recognize the Skill in conversations.

In Claude Code and Other Tools¶

Claude Code and other tools usually support placing the Skill directory in .claude/skills/ or the user-level ~/.claude/skills/. Cursor documentation also states that it will support loading paths such as .claude/skills/ and .codex/skills/. The specific directory shall prevail according to the official documentation of each tool; the core requirement is “one folder + one SKILL.md”.

Typical Usage Examples¶

yeet will not automatically trigger after the Agent finishes modifying the code. The official description clearly states: “Use only when the user explicitly asks…”. Therefore, you need to clearly state your full intent in the conversation, for example:

Help me stage, commit, push the current changes, and open a GitHub PR with the description fix login redirect loop

Or more colloquially:

Yeet it, use feat: add retry for API timeout as the commit message

After the Agent reads the yeet Skill, it will roughly execute the following command sequence (replace {description} with your input):

# Create a branch first if on the default branch
git checkout -b "fix-login-redirect-loop"

git status -sb
git add -A
git commit -m "fix login redirect loop"

git push -u origin $(git branch --show-current)

# Create draft PR without existing PR (add --template if template exists)
GH_PROMPT_DISABLED=1 GIT_TERMINAL_PROMPT=0 \
  gh pr create --draft --fill \
  --head "$(git branch --show-current)"

# Write body to temporary file (real line breaks), then edit PR
gh pr edit --body-file /tmp/pr-body.md

If there is already a PR on the current branch, the Agent will take the update path instead of creating a new one with --draft:

gh pr view "$(git branch --show-current)" --json number --jq '.number'
gh pr edit <number> --title "fix: login redirect loop" --body-file /tmp/pr-body.md

Naming Conventions¶

The branch, commit, and PR titles of the official curated version all default to revolving around {description}:
| Object | Rules |
|------|------|
| Branch name | Use {description} when checking out from the default branch |
| Commit message | Short {description} |
| PR title | Summarize the full diff; recommended type(scope): summary format |

Community mirrors (such as yeet in JetBrains/skills) may use codex/{description} branch prefixes or [codex] PR title prefixes — if you are using a forked version, refer to the actual SKILL.md.

Applicable Scenarios and Notes¶

Who and what scenarios it is suitable for:
- After finishing daily feature development, you want the Agent to help you submit and open a Draft PR once, and then go to GitHub to edit the title and add reviewers yourself
- The team repository has a PR template configured, and you want the Agent to fill in Why / What according to the template instead of generating vague descriptions
- Iterate multiple times on the same feature branch, and need to update the existing PR instead of creating a duplicate one
- Already using gh to manage GitHub, and want to hand over the “last mile” to the Agent

Restrictions to note:
1. Must be triggered explicitly — the Agent will not commit or push without your request (which aligns with many project security specifications).
2. git add -A stages all changes — if there are files you do not want to commit, manually add them to .gitignore or adjust them first, then ask the Agent to execute yeet.
3. New PRs default to Draft — this lets you review the diff one last time; existing PRs will not be changed back to Draft.
4. Depends on gh and GitHub — not applicable to GitLab, Gitee and other platforms.
5. openai/skills repository has been deprecated — follow the OpenAI Plugins documentation for long-term maintenance; you can still directly copy SKILL.md for short-term use.
6. Retry on push failure — the Skill mentions that if the push fails due to workflow authentication errors, it will pull the default branch and retry; complex conflicts still require manual intervention.

Summary¶

yeet encapsulates the developer’s most frequent Git final steps — staging, committing, pushing, and opening a PR — into a reusable Agent Skill instruction. It does not replace Code Review or CI, but it standardizes the repetitive work from finishing code changes to having a PR appear on GitHub, and also takes into account engineering details such as PR templates, existing PR updates, and Conventional Commit titles.

If you are already using Cursor, Codex or Claude Code, you might as well install the official yeet into .cursor/skills/ (or the corresponding directory), and next time after finishing code changes, just say “Help me yeet the changes out” — leave the rest to the Agent and gh.

Official Skill directory: https://github.com/openai/skills/tree/main/skills/.curated/yeet

yeet: Official OpenAI Skill, Run stage → commit → push → Create PR in one sentence