Agent skill

PR Lifecycle

by bradygaster in bradygaster/squad

Complete issue → PR → merge lifecycle with readiness checks. An agent skill from bradygaster/squad.

MITAuto-check passedDevelopment

Install PR Lifecycle

skills CLI
$ npx skills add bradygaster/squad --skill pr-lifecycle -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install bradygaster/squad pr-lifecycle --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/bradygaster/squad.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.copilot/skills/pr-lifecycle .claude/skills/pr-lifecycle && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
pr-lifecycle
GitHub stars
3.3k
Token cost
~4.8k tokens
SKILL.md length
1,667 words
Files
1
Skills in repo
31
Repo updated
First seen
Licence
MIT

At a glance

Complete issue → PR → merge lifecycle with readiness checks. An agent skill from bradygaster/squad.

  • Works in 6 steps: Issue Pickup → Implementation → PR Creation → …
  • Tasks that involve Git workflow
  • SKILL.md covers Context, Scope, Lifecycle Procedure and Examples, plus 2 more sections
  • Calls git, gh and npm

What it does

PR Lifecycle is an agent skill from bradygaster/squad. Complete issue → PR → merge lifecycle with readiness checks

Its SKILL.md is about 4.8k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Development, covering Git workflow. It works with Git. The repository describes itself as: Squad: AI agent teams for any project. The licence is MIT.

When your agent uses it

  • Tasks that involve Git workflow

Example prompts

  • “/pr-lifecycle”

Requirements

  • Node.js

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Issue Pickup
  2. Implementation
  3. PR Creation
  4. PR Readiness
  5. Post-Creation Maintenance
  6. Merge & Cleanup

What it can do on your machine

Read from SKILL.md and the folder at commit 1fd7e03. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • git
    • gh
    • npm
    • npx

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use git, gh, npm and npx, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

PR Lifecycle loads about 4.8k tokens when it runs. Until then it costs about 18 tokens; SKILL.md has 1,667 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~18
When it runs · the whole SKILL.md, loaded when a task matches
~4.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from bradygaster/squad at commit 1fd7e03, republished under its MIT licence (© bradygaster). 1,667 words, ~4,782 tokens.

Download SKILL.mdSave it as .claude/skills/pr-lifecycle/SKILL.md (or your agent's skills folder).
name
pr-lifecycle
description
Complete issue → PR → merge lifecycle with readiness checks
domain
workflow
confidence
high
source
extracted from CONTRIBUTING.md, PR_REQUIREMENTS.md, squad-ci.yml

Context

This skill is the canonical Copilot-agent lifecycle for the Squad repository. It covers the full path from picking up a GitHub issue to merging a PR. Where older docs (templates, copilot-instructions, CONTRIBUTING.md) conflict with this skill, this skill takes precedence for Copilot agents.

For advanced scenarios (worktrees, multi-repo coordination), see .copilot/skills/git-workflow/SKILL.md.

Scope

✅ THIS SKILL COVERS:

  • Issue pickup and branch creation
  • Implementation, build, test, lint workflow
  • Pre-push safety verification
  • PR creation with correct target, title, body, and labels
  • All 11 PR readiness checks (what they check, how to pass, how to fix)
  • Post-creation maintenance (review feedback, rebasing, CI)
  • Merge preconditions and cleanup

❌ THIS SKILL DOES NOT COVER:

  • Worktree-based parallel work (see git-workflow skill)
  • Multi-repo coordinated PRs (see git-workflow skill)
  • Release process / publishing (see .squad/skills/release-process)
  • Reviewer lockout protocol (see .copilot/skills/reviewer-protocol)
  • Architectural or security review checklists

Lifecycle Procedure

Phase 1 — Issue Pickup
  1. Read the issue. Understand the acceptance criteria before writing code.

  2. Confirm capability fit. Check your capability profile in .squad/team.md. 🟢 = proceed. 🟡 = proceed but flag in PR. 🔴 = comment on issue and stop.

  3. Branch from dev:

    bash
    git fetch origin dev
    git checkout dev
    git rebase origin/dev
    git checkout -b squad/{issue-number}-{slug}
    • Branch name format: squad/{issue-number}-{kebab-case-slug}
    • Example: squad/42-fix-login-validation
    • Never branch from main
  4. Mark in-progress (optional):

    bash
    gh issue edit {number} --add-label "status:in-progress"

Phase 2 — Implementation
  1. Make your changes. Follow the codebase conventions:

    • TypeScript strict mode, no @ts-ignore
    • ESM-only, async/await
    • JSDoc on new public APIs
  2. Build:

    bash
    npm run build
  3. Test:

    bash
    npm test
  4. Type check:

    bash
    npm run lint
  5. Stage specific files only:

    bash
    git add path/to/file1.ts path/to/file2.ts
    • ❌ NEVER git add ., git add -A, or git commit -a
    • ✅ ALWAYS name each file explicitly
  6. Pre-push safety check:

    bash
    # Verify file count matches intent (expect ≤10 files for most fixes)
    git diff --cached --stat
    
    # Verify NO unintended deletions
    git diff --cached --diff-filter=D --name-only

    If you see unexpected files or deletions, unstage them: git reset HEAD <file>

  7. Single commit with issue reference:

    bash
    git commit -m "Brief description of change
    
    Closes #{issue-number}
    
    Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>"
    • If you already have multiple commits, squash: git rebase -i origin/dev and squash all into one
    • Never use git reset --soft to squash — it picks up delta from dev and contaminates the commit
  8. Add changeset (if required): A changeset is required when your PR modifies files under packages/squad-sdk/src/ or packages/squad-cli/src/.

    bash
    npx changeset add

    This prompts for: which packages changed, bump type (patch/minor/major), summary.

    Or create manually at .changeset/{descriptive-name}.md:

    markdown
    ---
    '@bradygaster/squad-cli': patch
    ---
    
    Brief description of the change

    If the changeset creates a second commit, squash it into your main commit.


Phase 3 — PR Creation
  1. Push:

    bash
    git push -u origin squad/{issue-number}-{slug}
  2. Create PR targeting dev:

    bash
    gh pr create --repo bradygaster/squad --base dev \
      --title "fix: brief description (#issue-number)" \
      --body "Closes #{issue-number}
    
    ## Summary
    What this PR does and why.
    
    ## Changes
    - File-level description of changes
    
    Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>"
  3. Title conventions:

    • Bug fix: fix: description (#N)
    • Feature: feat: description (#N)
    • Docs: docs: description (#N)
    • Chore/infra: chore: description (#N)
  4. Labels:

    • fix, feat, docs, or repo-health for type
    • squad:{agent-name} if working as a squad member
    • skip-changelog only with reviewer approval (escape hatch)
  5. Scope rules by label:

    • repo-health: Only modify .github/, scripts/, root config, tests, docs. Never modify packages/*/src/
    • fix or feat: May modify product source. Must include changeset when touching packages/*/src/

Phase 4 — PR Readiness

An automated readiness check runs on every push and posts a checklist comment on the PR. All 11 checks must pass before review (check 11 is informational-only).

Check 1: Single Commit
WhatPR must contain exactly 1 commit
PassPush a single, squashed commit
Fixgit rebase -i origin/dev → squash all commits into one → git push --force-with-lease
GotchaNever git reset --soft to squash — contaminates the commit with unrelated changes
Check 2: Not in Draft
WhatPR must not be marked as draft
PassCreate PR as ready, or convert: gh pr ready
Fixgh pr ready {number} or use the GitHub UI
GotchaThe readiness check still runs on drafts but will show ❌ until you mark ready
Check 3: Branch Up to Date
WhatPR branch must not be behind dev
PassRebase onto latest dev before pushing
Fixgit fetch origin dev && git rebase origin/dev && git push --force-with-lease
GotchaAfter rebasing, the readiness check re-runs automatically on the new push
Check 4: Copilot Review
WhatThe copilot-pull-request-reviewer bot must post an APPROVED review
PassWait — Copilot review is triggered automatically on PR creation/push
FixIf Copilot hasn't reviewed after 5 minutes, push an empty commit to re-trigger: git commit --allow-empty -m "trigger review" && git push then squash before merge
GotchaCopilot review state is APPROVED, CHANGES_REQUESTED, or COMMENTED. Only APPROVED passes
Check 5: Changeset Present
WhatPRs that modify packages/squad-sdk/src/ or packages/squad-cli/src/ must include a .changeset/*.md file or a CHANGELOG.md edit
PassRun npx changeset add and commit the generated file
Fixnpx changeset add → select affected package(s) → select bump type → write summary → git add .changeset/ && git commit --amend --no-edit && git push --force-with-lease
GotchaThe skip-changelog label bypasses this check but requires reviewer approval. Non-source changes (docs, config, tests) don't need a changeset
Check 6: No Merge Conflicts
WhatPR must be cleanly mergeable with the base branch
PassKeep branch rebased on dev
Fixgit fetch origin dev && git rebase origin/dev → resolve conflicts → git push --force-with-lease
GotchaGitHub may show null mergeability briefly while computing — the check treats this as passing
Check 7: Scope Clean
WhatWarns if PR includes .squad/ or docs/proposals/ files
PassDon't include team state or proposal files in product PRs
FixRemove unintended files: git reset HEAD .squad/ docs/proposals/ then amend your commit
GotchaThis check is informational only — it always passes but flags attention. Including these files is OK if intentional (e.g., updating agent history)
Check 8: Copilot Threads Resolved
WhatAll review threads opened by copilot-pull-request-reviewer must be resolved
PassAddress each Copilot comment, then click "Resolve conversation" in the GitHub UI
FixGo to the PR's "Files changed" tab → find unresolved Copilot threads → fix the code or explain why no change is needed → click "Resolve conversation"
GotchaOutdated threads (on code that's since changed) are automatically skipped. Only active, unresolved threads block
Check 9: CI Passing
WhatAll CI check runs (excluding the readiness check itself) must be green
PassFix any build, test, or lint failures and push
FixRead the failing check's logs (gh run view {run-id} --log-failed), fix the issue, push
GotchaPending/in-progress checks also show ❌. Wait for all checks to complete before evaluating. The readiness check re-runs after CI completes via workflow_run trigger
Show full SKILL.md (730 more words)Show less
Check 10: Issue Linked
WhatPR body or commit message must reference an issue (Closes #N, Fixes #N, Resolves #N, or Part of #N)
PassInclude Closes #N in PR body or commit message
FixEdit PR body to add Closes #{issue-number}, or amend commit message
GotchaCase-insensitive matching. Only closing keywords are recognized
Check 11: Protected Files (informational)
WhatWarns when zero-dependency bootstrap files are modified (always passes)
PassAlways passes — this is informational only
FixIf flagged, verify the changed bootstrap file still has zero external dependencies
GotchaProtected files are listed in copilot-instructions.md. The check warns but does not block

Phase 5 — Post-Creation Maintenance
  1. Handling Copilot review feedback:

    • Read each comment carefully
    • Fix valid issues in your code
    • Resolve each thread after addressing it
    • Amend your single commit: git commit --amend --no-edit && git push --force-with-lease
  2. Rebasing when behind dev:

    bash
    git fetch origin dev
    git rebase origin/dev
    # Resolve any conflicts
    git push --force-with-lease
  3. Re-running CI:

    • CI re-runs automatically on every push
    • To re-run without changes: gh run rerun {run-id} --failed
  4. If readiness check is stale:

    • The readiness check re-runs on push and after CI completes
    • If it's stale, push a trivial fix or empty commit to re-trigger

Phase 6 — Merge & Cleanup
  1. Merge preconditions:

    • All 11 readiness checks pass (✅ across the board)
    • Human reviewer has approved (or maintainer merges directly)
    • No open blocking conversations
  2. Who merges:

    • Agents do not merge PRs themselves
    • Maintainers (bradygaster or designated reviewers) merge via GitHub UI
    • The repo uses squash merge, so commit history is clean regardless
  3. Post-merge cleanup:

    bash
    git checkout dev
    git pull origin dev
    git branch -d squad/{issue-number}-{slug}
    git push origin --delete squad/{issue-number}-{slug}
  4. Verify issue auto-close:

    • If PR body contains Closes #{N}, the issue closes automatically on merge
    • If not, manually close: gh issue close {number}

Examples

Example: Bug fix PR (no source changes)
bash
# Branch
git fetch origin dev && git checkout dev && git rebase origin/dev
git checkout -b squad/610-fix-broken-link

# Fix
# ... edit docs/some-file.md ...

# Validate
npm run build && npm test

# Commit (no changeset needed — docs only)
git add docs/some-file.md
git diff --cached --stat        # verify: 1 file
git commit -m "docs: fix broken link in contributing guide

Closes #610

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>"

# Push and PR
git push -u origin squad/610-fix-broken-link
gh pr create --repo bradygaster/squad --base dev \
  --title "docs: fix broken link (#610)" \
  --body "Closes #610"
Example: SDK feature PR (source changes)
bash
# Branch
git fetch origin dev && git checkout dev && git rebase origin/dev
git checkout -b squad/42-add-profile-api

# Implement
# ... edit packages/squad-sdk/src/profile/index.ts ...
# ... edit packages/squad-sdk/src/index.ts (re-export) ...

# Validate
npm run build && npm test && npm run lint

# Changeset (required — touches packages/squad-sdk/src/)
npx changeset add
# Select: @bradygaster/squad-sdk, minor, "Add profile API"

# Stage and commit
git add packages/squad-sdk/src/profile/index.ts packages/squad-sdk/src/index.ts .changeset/
git diff --cached --stat                    # verify file count
git diff --cached --diff-filter=D --name-only  # verify no deletions
git commit -m "feat: add profile API

Closes #42

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>"

# Push and PR
git push -u origin squad/42-add-profile-api
gh pr create --repo bradygaster/squad --base dev \
  --title "feat: add profile API (#42)" \
  --body "Closes #42

## Summary
Adds profile resolution API to the SDK.

## Changes
- New module: packages/squad-sdk/src/profile/
- Re-exported from barrel file"

Anti-Patterns

  • ❌ Branching from main (always branch from dev)
  • ❌ Targeting main with PRs (always target dev)
  • ❌ Using git add . or git add -A (stage specific files only)
  • ❌ Using git commit -a (same risk as broad staging)
  • ❌ Using git reset --soft to squash (contaminates commit with dev delta)
  • ❌ Force-pushing to dev or main (only force-push your own feature branch)
  • ❌ Merging your own PR (maintainers merge)
  • ❌ Skipping the changeset when source files changed (CI will fail)
  • ❌ Self-resolving Copilot threads without addressing the feedback
  • ❌ Pushing >1 commit without squashing (readiness check will flag it)
  • ❌ Including .squad/ files in product PRs without intention (scope check warns)
  • ❌ Mixing product and infrastructure changes in one PR (create separate PRs)

Readiness Check Gaps & Recommendations

After analyzing .github/workflows/squad-ci.yml, three gaps were identified. Gaps 1 and 3 are now implemented (checks 10 and 11). Gap 2 is deferred.

Gap 1: Issue Linkage Check (Check 10) — IMPLEMENTED

Problem: Nothing verifies that the PR body or commit message references an issue (Closes #N or Part of #N). Orphan PRs are hard to trace.

Recommendation: Add checkIssueLinkage(prBody, commitMessages) to pr-readiness.mjs.

javascript
/**
 * Check: Issue linkage.
 * @param {string} prBody — PR description text
 * @param {Array<{ commit: { message: string } }>} commits
 * @returns {{ pass: boolean, detail: string }}
 */
export function checkIssueLinkage(prBody, commits) {
  const issuePattern = /(closes|fixes|resolves|part of)\s+#\d+/i;
  const bodyHasRef = issuePattern.test(prBody || '');
  const commitHasRef = (commits || []).some(
    (c) => issuePattern.test(c.commit?.message || '')
  );
  if (bodyHasRef || commitHasRef) {
    return { pass: true, detail: 'Issue reference found' };
  }
  return {
    pass: false,
    detail: 'No issue reference — add `Closes #N` to PR body or commit message',
  };
}

Integration point: After check 2 (draft status), before check 3 (branch freshness). Data is already available from the commits and PR body fetched in the orchestrator.

Gap 2: No Required Checks Presence Verification

Problem: The CI status check (check 9) verifies that existing checks are green, but doesn't verify that the expected set of checks actually ran. If a workflow is misconfigured or skipped, the PR could pass with zero CI checks.

Recommendation: Add checkRequiredChecksPresent(checkRuns, files) to pr-readiness.mjs.

javascript
/** Minimum required check names that must appear for source PRs. */
export const REQUIRED_CHECKS = ['Squad CI / test'];

/**
 * Check: Required CI checks are present.
 * @param {Array<{ name: string }>} checkRuns
 * @param {Array<{ filename: string }>} files
 * @returns {{ pass: boolean, detail: string }}
 */
export function checkRequiredChecksPresent(checkRuns, files) {
  const touchesSource = (files || []).some(
    (f) => SOURCE_PATTERN.test(f.filename)
  );
  if (!touchesSource) {
    return { pass: true, detail: 'No source changes — required checks not enforced' };
  }
  const checkNames = new Set((checkRuns || []).map((cr) => cr.name));
  const missing = REQUIRED_CHECKS.filter((name) => !checkNames.has(name));
  if (missing.length > 0) {
    return {
      pass: false,
      detail: `Required check(s) not found: ${missing.join(', ')}`,
    };
  }
  return { pass: true, detail: 'All required checks present' };
}

Integration point: After check 9 (CI status). Uses the same checkRuns and files data already fetched.

Gap 3: Protected File Change Detection (Check 11) — IMPLEMENTED

Problem: The repo has zero-dependency bootstrap files that must never import external packages (documented in copilot-instructions.md). The squad-repo-health.yml workflow runs a bootstrap protection check, but the PR readiness comment doesn't surface it — contributors don't see the warning until they check the separate workflow.

Recommendation: Add checkProtectedFiles(files) to pr-readiness.mjs as an informational check (always passes, like scope clean).

javascript
/** Bootstrap files that must remain zero-dependency. */
export const PROTECTED_FILES = [
  'packages/squad-cli/src/cli/core/detect-squad-dir.ts',
  'packages/squad-cli/src/cli/core/errors.ts',
  'packages/squad-cli/src/cli/core/gh-cli.ts',
  'packages/squad-cli/src/cli/core/output.ts',
  'packages/squad-cli/src/cli/core/history-split.ts',
];

/**
 * Check: Protected file changes (informational).
 * @param {Array<{ filename: string }>} files
 * @returns {{ pass: boolean, detail: string }}
 */
export function checkProtectedFiles(files) {
  const touched = (files || []).filter(
    (f) => PROTECTED_FILES.includes(f.filename)
  );
  if (touched.length === 0) {
    return { pass: true, detail: 'No protected bootstrap files changed' };
  }
  return {
    pass: true,
    detail: `⚠️ ${touched.length} protected bootstrap file(s) changed: ${touched.map((f) => f.filename.split('/').pop()).join(', ')} — verify zero-dependency constraint`,
  };
}

Integration point: After check 7 (scope clean). Uses the same files data. Informational only — warns but doesn't block.

CheckTypeBlocks PR?Status
Issue linkage (Check 10)Hard gateYesImplemented
Required checks presentHard gateYesDeferred
Protected file warning (Check 11)InformationalNoImplemented

All three use data that pr-readiness.mjs already fetches — no new API calls needed. Total addition: ~60 lines of check functions + ~10 lines of orchestration wiring.

© bradygaster, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .copilot/skills/pr-lifecycle of bradygaster/squad.

Open the folder on GitHubat commit 1fd7e03

Compare with similar skills

PR Lifecycle next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

PR Lifecycle compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
PR Lifecycle this skillbradygaster/squad3.3k—~4.8kAutomated safety check: PassMIT
Finishing a Development Branchobra/superpowers296k5 repos~1.9kAutomated safety check: PassMIT
Code Design Rationale Investigatorcursor/plugins10k9 repos~2.6kAutomated safety check: PassNone
Contributor-First PR MergeHKUDS/OpenHarness16k1 repos~847Automated safety check: PassMIT
Migrate Internal Package into GhostTryGhost/Ghost55k—~3.8kAutomated safety check: PassMIT
Create Pull Requestcline/cline70k1 repos~1.6kAutomated safety check: PassApache-2.0

Similar skills

  • Walks the last step of a branch: confirm tests pass, detect the git environment, ask how to integrate, carry out your choice and clean up the worktree.

    296k GitHub starsUsed in 5 repos~1.9k tokens
    DevelopmentAuto-check passed
  • Official

    Digs into why code is shaped the way it is by checking git history, pull requests and connected tools in parallel, then reporting a cited read on the tradeoffs.

    10k GitHub starsUsed in 9 repos~2.6k tokens
    DevelopmentAuto-check passed
  • Merges external GitHub pull requests while keeping the original author credited, and fixes conflicts after the merge instead of rewriting the contribution.

    16k GitHub starsUsed in 1 repo~847 tokens
    DevelopmentAuto-check passed
  • Moves a package from another TryGhost repository into Ghost as an internal workspace package while keeping its Git history, with checkpoints for the steps that need an administrator.

    55k GitHub stars~3.8k tokensUpdated yesterday
    DevelopmentAuto-check passed
  • Opens a GitHub pull request from your current branch with the gh CLI, after reviewing the commits and diff and gathering the details the PR needs.

    70k GitHub starsUsed in 1 repo~1.6k tokens
    DevelopmentAuto-check passed
  • Git Merge Conflict Resolver

    tailcallhq/forgecode

    Resolves Git merge conflicts with a plan-first workflow that keeps both sides' intent, regenerates lock files and backs up deleted-but-modified files.

    7.6k GitHub starsUsed in 1 repo~4.5k tokens
    DevelopmentAuto-check passed

More from bradygaster/squad

All 31 skills in this repo
  • Fact Checking

    bradygaster/squad

    Review and validate claims using counter-hypothesis testing.

    3.3k GitHub stars~503 tokensUpdated today
    Auto-check passed
  • Architectural Review

    bradygaster/squad

    How to review PRs for architectural quality — module boundaries, dependency direction, export surface, pattern consistency

    3.3k GitHub stars~2.2k tokensUpdated today
    Auto-check passed
  • Archival Integrity

    bradygaster/squad

    Preserve content when moving entries between tracked Squad state files

    3.3k GitHub stars~735 tokensUpdated today
    Auto-check passed
  • CI Validation Gates

    bradygaster/squad

    Defensive CI/CD patterns: semver validation, token checks, retry logic, and draft detection

    3.3k GitHub stars~1.1k tokensUpdated today
    Auto-check passed
  • CLI Wiring

    bradygaster/squad

    Checklist and patterns for wiring new CLI commands into cli-entry.ts

    3.3k GitHub stars~501 tokensUpdated today
    Auto-check passed
  • Enables squad agents on different machines to share work via git-based task queuing

    3.3k GitHub stars~2.7k tokensUpdated today
    Auto-check passed

Works with

Categories

Questions about PR Lifecycle

What does PR Lifecycle do?

Complete issue → PR → merge lifecycle with readiness checks. An agent skill from bradygaster/squad. PR Lifecycle is an agent skill from bradygaster/squad.

When should I use PR Lifecycle?

PR Lifecycle fits situations like: tasks that involve Git workflow.

How do I install PR Lifecycle in Claude Code?

Run `npx skills add bradygaster/squad --skill pr-lifecycle -a claude-code`. Or copy the skill folder (.copilot/skills/pr-lifecycle in bradygaster/squad) into .claude/skills/pr-lifecycle in your project. Claude Code loads it when a task matches its description.

How do I install PR Lifecycle in Codex?

Run `npx skills add bradygaster/squad --skill pr-lifecycle -a codex`. Or copy the skill folder (.copilot/skills/pr-lifecycle in bradygaster/squad) into .agents/skills/pr-lifecycle in your project. Codex loads it when a task matches its description.

Can I use PR Lifecycle in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add bradygaster/squad --skill pr-lifecycle -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/pr-lifecycle, .gemini/skills/pr-lifecycle, .github/skills/pr-lifecycle and .opencode/skills/pr-lifecycle in your project.

What does PR Lifecycle need to run?

Going by SKILL.md and its folder, PR Lifecycle needs the command-line tools its instructions call (git, gh, npm and npx). Our summary lists: Node.js.

Does PR Lifecycle access the network?

SKILL.md contains no URLs. Its commands use git, gh, npm and npx, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is PR Lifecycle safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does PR Lifecycle use?

PR Lifecycle is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does PR Lifecycle use?

About 4.8k tokens (SKILL.md is roughly 19k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to PR Lifecycle?

Skills that share tags, products or a category with PR Lifecycle: Finishing a Development Branch (obra/superpowers, 296k stars), Code Design Rationale Investigator (cursor/plugins, 10k stars), Contributor-First PR Merge (HKUDS/OpenHarness, 16k stars) and Migrate Internal Package into Ghost (TryGhost/Ghost, 55k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains PR Lifecycle?

bradygaster (a GitHub user) maintains it in bradygaster/squad, which has 3,257 GitHub stars. The repository holds 31 skills in this directory. The repository was last updated on October 8, 2026.

Source: bradygaster/squad on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.