Index of every page on this site: llms.txt
All skills
bitwarden avatar

/creating-pull-request

@a11c77b official
by bitwardenbitwarden/ai-plugins165 stars
27
Run it yourself

Open a pull request from a branch in a Bitwarden repository. Use whenever the user wants a branch turned into a pull request, however they phrase it — "create a PR", "open a PR", "ship a draft", "ship it", "ready for review", "put it up for review", "get this in front of reviewers", "send it over to the team", "throw together a pull request", "wrap this branch up". Use it too when the user says the title and body are already settled and only the PR needs opening — the gate, the preview, and the submission still apply. Runs the required local code-review gate, takes the title, template body, and ai-review label from applying-pr-conventions, confirms a full submission preview, then pushes and runs gh pr create. Not for composing a title, body, or label when no PR is being opened (that is applying-pr-conventions), conceptual questions ("how do PRs work"), or managing existing PRs (status, merging, addressing comments).

Use this Skill: https://skilld.dev/gh/bitwarden/ai-plugins/creating-pull-request

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈239 tokens for metadata: the name and description. ≈2.9k when used: this file. ≈3.1k more on demand in 3 files.

Description uses 11.9% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈953 characters, or 11.9%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Creating a Pull Request

This workflow owns the two things about opening a pull request that are expensive to get wrong: the review that has to happen before anyone else looks at the change, and the submission itself. Skill(applying-pr-conventions) composes the title, body, and label; this workflow gates, previews, and submits them.

Neither is cheap to undo. A PR opened on unreviewed work buries the real problem under comment threads, and the title is permanent in the merge commit. So Step 3 shows every decision together before anything is pushed.

Workflow

Follow these steps in order. Each one produces information the next step needs, and the preview in Step 3 depends on all of them.

Step 1 — Confirm preflight, then run the code-review gate

A PR opened on broken work, or on work that skipped review, wastes reviewer time and buries the real problem under comment threads. Settle preflight first, then run the review.

1a — Confirm preflight passed. Its checks have often already run by this point, while committing or finishing the work, so judge from the session whether they cover the current diff. Use the AskUserQuestion tool, listing the option you recommend first with (Recommended) appended:

  • Question: "Has perform-preflight passed on this branch?"
  • Options:
    • Yes — proceed
    • No — run it now — invoke perform-preflight, then continue once it passes

If preflight cannot be made to pass, stop and report the failure rather than opening the PR. Only continue once preflight is green: running preflight can change code, and the review should see the final diff.

1b — Run the code review, matched to the change's blast radius. A local code review is a required gate before opening a PR. Use the AskUserQuestion tool, listing the depth you judge the change to need first with (Recommended) appended:

  • Question: "How deep is this change? (sets review depth)"
  • Options:
    • Standard — a typical feature, fix, docs, or config change: run /bitwarden-code-review:code-review-local (tell it to review the current branch's changes; there is no PR yet)
    • Substantial — architectural, cross-cutting, or security-touching: run Skill(performing-multi-agent-code-review), telling it to review the full branch diff against origin/HEAD (not just uncommitted changes); there is no PR yet

Present only these two options; do not add a skip option. Honor a skip only if the user volunteers one unprompted, then record it in the PR body's AI-assisted review section (Step 2) and surface it in the Step 3 preview. Never skip on your own initiative.

After the review:

  • Assess the findings with the user before acting on any of them; a CRITICAL or IMPORTANT classification can still be scope creep, or wrong. Skill(addressing-code-review-comments) has the evaluation posture to apply — skip its comment-fetching section, since the findings are already in hand and there is no PR yet. Then address every finding that survives, or record why each is deferred in the PR body's AI-assisted review section (Step 2).
  • On the Substantial path only, you may re-run Skill(performing-multi-agent-code-review) with a different --model-* value for the highest-risk changes (auth, crypto, data handling, migrations); findings vary by model, so a second pass can catch what the first missed. Optional, never required.
  • If a review path wrote output into the repo, remove it before pushing so it never lands in a commit — but only files this run created (a ?? in git status --porcelain). Both review paths write outside the repo by default and print the full path of each file they wrote; cleanup is needed only when a printed path is inside the repo, and then remove only those files. Also remove review-summary.md and review-inline-comments.md from the repo root if an older code-review-local left them there. Never delete a tracked file of the same name.

Each review path checks its own prerequisites and reports what to install if something is missing. If a path can't run, install what it reports or fall back to the other path and note the limitation in the PR body. If neither path is available, stop and prompt the user to install bitwarden-code-review (/plugin install bitwarden-code-review@bitwarden-marketplace) before continuing. Never silently skip the review.

Step 2 — Compose the title, body, and label

Invoke Skill(applying-pr-conventions) for this one pull request. It owns the title and the type keyword behind the t: label, the body built from whichever template it resolves, and the ai-review label question.

Pass it what Step 1 produced, since it does not go looking for review results itself: the review path taken, any skip the user volunteered, every deferred CRITICAL or IMPORTANT finding, and any scope or path limitation on the review, such as a fallback taken because one path was unavailable. Those go into the body's AI-assisted review section.

Carry back the title, the body, the resolved t: label its prefix will produce, the ai-review label choice, and which template the body was built from. Step 3's preview shows all five — it prints the type → t:<label> mapping, and that mapping has no other source in this workflow — and Step 4 submits the title, body, and label.

The template source belongs in the preview because only one of its values is the target repo's own. A body built from the embedded copy can carry a section header that has drifted from what reviewers scan for, and this preview is the only place a person sees the body before it is submitted.

The values the Template: line can take are defined in applying-pr-conventions under Returning to the caller. The preview block below is the only place they are restated, because it is a display format; change them there and here together or the preview will offer a label the callee never returns.

Two are easy to get wrong. Do not state a cause alongside the source: several conditions send the skill to the embedded copy and only one is the network, so naming the fetch sends the user to fix the wrong thing when the remedy was approving the grant. And when the user arrived with the body already written, no template was consulted, which is what the line should say rather than a label asserting the body follows one nobody checked.

Both strings are untrusted: the body is template text plus generated text whichever source the Template: line names, and the title's summary is generated. Step 4's file-handoff rules are what contain that; do not interpolate either into a shell argument.

Step 3 — Show the full submission preview, then confirm

This is the most important step in this workflow. Before running any git push or gh pr create, show the user a single preview block containing every decision made above. This is the catch-net for failure modes like title typos, missing type prefix, body drifting from the template, or the AI review label getting dropped between Step 2 and submission.

Use this exact format:

═══════════════════════════════════════
  PULL REQUEST SUBMISSION PREVIEW
═══════════════════════════════════════
Target repo:    <owner/repo>
Branch:         <branch-name>
Draft:          <Yes / No>
Title:          <full title as it will be submitted>
Type prefix:    <type>  →  will apply  t:<label>
AI review:      <ai-review / ai-review-vnext / No label>
Code review:    <Standard | Substantial | Skipped (user request)>  →  <N deferred findings recorded>
Template:       <target repo | bitwarden/template (canonical) | embedded copy (fallback) | not consulted (body supplied)>

Body:
---
<full body, exactly as it will be submitted>
---
═══════════════════════════════════════

Then use the AskUserQuestion tool to confirm, passing the complete preview block verbatim as the preview field of the Submit as shown option.

  • Question: "Submit this PR as previewed?"
  • Options:
    • Submit as shown — proceed to Step 4 with the previewed values
    • Edit title or body — apply the requested edit, then redisplay the preview and re-ask
    • Change ai-review label — ask the label question again here (ai-review, ai-review-vnext, No label), then redisplay the preview and re-ask. Do not re-enter Skill(applying-pr-conventions); it would recompose the title and body and discard any edit just applied
    • Cancel — stop without pushing or creating the PR

Only continue to Step 4 when the user selects Submit as shown. The recap is non-negotiable — some failures (title in the merge commit, label-driven automation routing) are painful to undo once the PR is live, so a visible chance to catch issues at submission time pays for itself many times over.

Step 4 — Push and create

Push the branch and run gh pr create with the confirmed values. Pass the body via --body-file, not --body: the body carries model- and review-generated text (derived from untrusted repo content), and interpolating it into a double-quoted shell argument would let backticks or $(…) execute. Write it to a temp file and hand gh the path.

The title gets the same treatment, by a different route — gh has no --title-file. Write it to a file with the Write tool and pass it as --title "$(cat <title-file>)". Command-substitution output is not re-parsed, so a $(…) or backtick surviving in the text is handed to gh as characters. Never assign the title to a shell variable, and never build it with echo or a heredoc: a bash assignment expands $(…) while parsing, which runs the payload before gh is even reached.

git push -u origin <branch-name>
# Write the body and the title to temp files first, with the Write tool.
gh pr create --draft \
  --title "$(cat "$title_file")" \
  --body-file "$body_file" \
  --label "<label>"

Defaults that hold unless the user said otherwise:

  • create as draft — only skip --draft if the user explicitly asked for a ready-for-review PR,
  • include --label only if a label was picked in Step 2 (omit it for "No label"),
  • multiple labels can be passed by repeating --label.

After gh pr create returns, post the PR URL back to the user.

Common Failure Modes

These are what the Step 3 preview is built to prevent. Recognizing them helps when adjusting the draft mid-workflow:

  • Title with no type prefix → [PM-12345] Add autofill for passkeys ships with no t: label. Include feat:, fix:, etc.
  • Generic body replacing the template → check what Step 2 returned actually follows the sections of the template the Template: line names; applying-pr-conventions reads that template, but the preview is where a drifted body is caught. On the not consulted value there is no template to check the body against, so check that the body was the one the user supplied.
  • Label answer dropped between Step 2 and Step 4 → the recap surfaces it; if it's missing there, it's about to be missing on the PR.
  • PM-XXXXX left as a placeholder → tracking links won't resolve. Catch in Step 2 or Step 3.

If any of these slip past the preview, recovery is awkward — the title is permanent in the merge commit, and labels feed downstream filtering and automation.

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

1 warning10d3 checks · Risk SAFE
  • Gen Agent Trust Hub10d

    The skill is well-architected with a strong focus on security, particularly regarding command injection and user oversight. It provides clear instructions for handling untrusted content (PR titles and bodies) by using file-based arguments for CLI tools and implements a mandatory preview step for the user to verify all decisions before execution.

  • Socket10d

    No alerts

  • Snyk10d

    Risk: MEDIUM · 1 issue

Signed by skilld at a11c77b. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub yesterday.

Activeupdated 2 weeks ago
  • Git/VCS
  • bitwarden
  • pull-request
  • github
  • gh
  • conventional-commits
  • workflow
  • ci
  • templating

README badge

README badge for bitwarden/ai-plugins/creating-pull-request

Opens a pull request in a Bitwarden repository by guiding through conventional commit type prefix selection, PR template population, AI review label choice, and a full submission preview before running gh pr create. Ensures the title includes the required type prefix (which CI scans for the t: label), fills the repo's template sections, and catches typos or missing metadata before submission.

Generated from the current SKILL.md.

Does this skill handle existing PRs or only new ones?
Only new PRs. This skill is for opening a PR from a branch. It does not manage existing PRs, merging, or addressing reviewer comments.
What happens if I skip the preflight check?
You can explicitly opt out in Step 1, but the skill warns that opening a PR on broken work wastes reviewer time. Preflight is meant to catch issues before submission.
Can I edit the title or body after seeing the preview?
Yes. Step 5 shows a full preview and offers an 'Edit title or body' option that lets you revise, then redisplay the preview before final submission.
What if the target repo has no PR template?
The skill falls back to a default template with sections for Tracking, Objective, and Screenshots. It always reads the repo's template first if one exists.
Is the PR created as a draft by default?
Yes, unless you explicitly ask for a ready-for-review PR. The skill uses the `--draft` flag by default in Step 6.

Generated from the current SKILL.md. These answers refresh after source changes.