Skip to content

Add code review skill for GitHub PRs and local branches#1572

Open
jason-capsule42 wants to merge 1 commit into
devfrom
jbaker/reviewSkill
Open

Add code review skill for GitHub PRs and local branches#1572
jason-capsule42 wants to merge 1 commit into
devfrom
jbaker/reviewSkill

Conversation

@jason-capsule42

@jason-capsule42 jason-capsule42 commented Jul 23, 2026

Copy link
Copy Markdown
Member

Alaska Airlines Pull Request

Executive Summary

This branch adds a /code-review Claude Code skill that encodes this repo's release conventions (ADO AB# traceability, Conventional Commits → semver, the post-mortem requirement, TRD deviations) into a repeatable, adversarial review. It runs in one of two modes keyed off its argument: a PR number reviews that pull request, posts reconciled inline + summary comments to GitHub, and mirrors this post-mortem's executive summary into the PR description, while local (or no argument) reviews the current branch against a chosen base and outputs to chat only — the destructive, outward-facing path is reachable exclusively via an explicit PR number.

The skill was hardened primarily by running it against its own PR: each pass surfaced genuine defects (a shell-injection-prone comment body, a case-sensitive keyword match, line-number-based comment reconciliation that duplicated after rebases, over-granted tool permissions) that were fixed in the same file. Two findings were structural to a review tool reviewing itself and required explicit carve-outs: .claude/** instructional prose is reviewed as ordinary content rather than flagged as prompt injection, and tooling changes are always chore, never a bump-triggering feat. The skill's unconditional post-mortem gate also fired a release-blocking finding on its own PR — this document is that resolution, and the rule was clarified to be waivable for pure .claude/ tooling.

One property is worth stating plainly, because it changes how the skill should be used: the review is adversarial and non-deterministic, so re-running it on an unchanged diff keeps surfacing new low-value nits. The personas sample different angles each pass, the prompt is tuned to hunt rather than to certify, and "consider also…" suggestions are effectively unbounded — so a run almost never comes back truly empty. What does converge is the part that matters: genuine 🔴 correctness/security/regression findings drop to zero and stay there; only 🟡 nits churn. The implementation choice was not to chase determinism (which would blunt the adversarial value) but to add an explicit convergence instruction: when only marginal polish remains, the reviewer must report the diff as clean and mark remaining nits optional rather than manufacture a finding to look productive. The real stopping signal is therefore "no 🔴/🟡 you'd act on, two runs running" — not a literally empty list.

Bottom line: one net-new tooling file (no shippable code, no semver impact), a review procedure proven by executing it end-to-end against a live PR, and the key lesson that gates firing on every change need a typed exemption for the change classes they don't apply to.

Synced from docs/post-mortem/1599649.md by the code-review skill.

Review Checklist:

  • My update follows the CONTRIBUTING guidelines of this project
  • I have performed a self-review of my own update
RC Checklist

Testing Checklist:

Browsers

Browsers Support Guide

Dev demo link

Android

  • Chrome
  • Firefox

iOS

  • Chrome
  • Firefox
  • Safari

Desktop

  • Chrome
  • Firefox
  • Safari
  • Edge

Scenarios

  • Validated linked issues with issue reporting team
  • Test coverage report review

Framework playground

  • Next React
  • SvelteKit

**By submitting this Pull Request, I confirm that my contribution is made under the terms of the Apache 2.0 license.**

Pull Requests will be evaluated by their quality of update and whether it is consistent with the goals and values of this project. Any submission is to be considered a conversation between the submitter and the maintainers of this project and may require changes to your submission.

Thank you for your submission!

-- Auro Design System Team

Summary by Sourcery

Add a new Claude Code /code-review skill that performs structured, adversarial reviews of GitHub PRs and local branches, and ship its accompanying post-mortem documenting design decisions and usage conventions.

New Features:

  • Introduce a code-review skill that can review either a specific GitHub PR with inline and summary comments or the current local branch with chat-only output.

Enhancements:

  • Encode repository-specific release and documentation conventions (AB# traceability, Conventional Commits, post-mortem/TRD requirements) into an automated review procedure.
  • Define safeguards and workflows for comment reconciliation, prompt-injection handling, and execution in constrained shell environments to harden the review process.

Documentation:

  • Add a detailed post-mortem for the new code-review skill, capturing rationale, behavior, limitations, and lessons learned for future maintenance and usage.

@sourcery-ai

sourcery-ai Bot commented Jul 23, 2026

Copy link
Copy Markdown

Reviewer's Guide

Adds a new Claude Code /code-review skill and its associated post-mortem, defining how to review GitHub PRs or local branches, gather repo-specific context, enforce release conventions, and post reconciled comments and executive summaries to GitHub.

Sequence diagram for PR-mode GitHub review and comment posting

sequenceDiagram
  actor User
  participant ClaudeSkill
  participant Git as Git_cli
  participant GH as Gh_cli
  participant API as GitHub_API

  User ->> ClaudeSkill: /code-review 1572
  ClaudeSkill ->> GH: gh pr view 1572 --json baseRefName,headRefOid,headRefName
  ClaudeSkill ->> Git: git fetch origin
  ClaudeSkill ->> Git: git rev-parse HEAD
  ClaudeSkill ->> ClaudeSkill: Compare local HEAD vs headRefOid
  alt SHAs differ
    ClaudeSkill -->> User: Warn mismatch and stop review
  else SHAs match
    ClaudeSkill ->> Git: git diff $(git merge-base <base> HEAD) HEAD
    ClaudeSkill ->> Git: git diff $(git merge-base <base> HEAD) HEAD --name-only
    ClaudeSkill ->> Git: git log <base>..HEAD --format="%s%n%b"
    ClaudeSkill ->> ClaudeSkill: Parse AB# refs, gather post-mortems, TRD, context
    ClaudeSkill ->> ClaudeSkill: Perform adversarial multi-persona review
    ClaudeSkill ->> GH: gh repo view --json owner,name
    ClaudeSkill ->> GH: gh pr view 1572 --json body
    ClaudeSkill ->> API: gh api --method PATCH repos/{owner}/{repo}/pulls/1572
    activate API
    Note right of API: Update PR description with synced Executive Summary
    API -->> ClaudeSkill: 200 OK
    deactivate API
    ClaudeSkill ->> GH: gh api --paginate repos/{owner}/{repo}/pulls/1572/comments
    ClaudeSkill ->> API: gh api repos/{owner}/{repo}/pulls/1572/comments (POST/PATCH)
    activate API
    Note right of API: Reconcile inline comments using inline marker
    API -->> ClaudeSkill: 2xx / 422
    deactivate API
    ClaudeSkill ->> GH: gh pr comment 1572 --body-file -
    ClaudeSkill ->> GH: gh pr view 1572 --json url --jq '.url'
    GH -->> User: PR URL with review results
  end
Loading

Flow diagram for /code-review argument handling and mode selection

flowchart TD
  A[/Invoke /code-review with $ARGUMENTS/] --> B["Normalize $ARGUMENTS<br>- trim whitespace<br>- strip leading #<br>- case-insensitive local"]

  B --> C{Is $ARGUMENTS numeric?}
  C -- Yes --> D["PR mode<br>- git fetch origin<br>- gh pr view $ARGUMENTS for baseRefName<br>- Determine &lt;base&gt; = origin/baseRefName or origin/dev fallback<br>- Head SHA check via gh pr view headRefOid<br>- If SHAs match: gather diff/log<br>- Post comments to GitHub"]

  C -- No --> E{Empty or local?}
  E -- Yes --> F["Local mode<br>- Ask user for base branch<br>- Resolve &lt;base&gt;<br>  - default via origin/HEAD or gh repo view<br>  - or user-specified ref<br>- git fetch origin<br>- Gather diff/log against merge-base<br>- Output findings in chat only"]

  E -- No --> G["Hard stop<br>Output warning:<br>&quot;Unrecognized argument — expected a PR number or local&quot;<br>No review performed"]
Loading

File-Level Changes

Change Details Files
Introduce a Claude Code /code-review skill that drives automated reviews for GitHub PRs and local branches, including tooling permissions and detailed procedural instructions.
  • Add SKILL frontmatter configuring name, description, context, and a least-privilege allowed-tools set for git and GitHub CLI operations.
  • Implement argument parsing and mode selection logic that distinguishes PR mode (numeric argument) from local mode (local or empty) and enforces early guardrails for invalid inputs.
  • Define PR-mode behavior: dynamic base branch resolution from the PR, SHA-based head-commit verification, merge-base-based diff gathering that excludes uncommitted changes, and GitHub-only side effects.
  • Define local-mode behavior: mandatory base-branch prompt, dynamic base resolution (default vs explicit branch), merge-base-based diff gathering that includes uncommitted work, and chat-only output.
  • Specify detailed review personas and checklists for bugs, security, regressions, framework integration, tests, documentation, and convergence rules to avoid manufacturing low-value nits.
  • Describe commit-message validation rules (AB# traceability, Conventional Commits prefixes, breaking-change signaling, and special handling for .claude/ tooling commits as chore).
  • Describe post-mortem and TRD discovery/validation, including recursive post-mortem traversal, TRD fetch via GraphQL, and handling of missing or unreachable TRDs.
  • Define GitHub comment posting semantics in PR mode: inline vs summary comments with hidden markers, reconciliation of previous inline comments, handling of anchoring failures, and a REST-based PR description update that syncs the executive summary from the post-mortem.
  • Document shell-sandbox fallbacks for command substitution and heredocs using explicit merge-base steps and temp files under /tmp via the Write tool.
.claude/skills/code-review/SKILL.md
Add a post-mortem documenting the design, behavior, and lessons of the new /code-review skill, and establishing repo conventions around tooling, post-mortems, and TRD handling.
  • Create a post-mortem file tied to ADO ticket AB#1599649 that describes the scope and non-semver nature of the new skill.
  • Include an Executive Summary that the skill will sync into PR descriptions in PR mode, explaining the adversarial, non-deterministic review behavior and convergence expectations.
  • Record reference documents and decisions, including the work item, PR reference, lack of TRD, and rationale for identifying commits by subject/branch/PR instead of pinned SHAs.
  • Detail what was planned vs what landed, motivation for the skill’s shape (disable auto-invocation, forked context, argument-driven modes), and how non-determinism is handled.
  • Capture issues found while dogfooding the skill (shell-injection risk, case-sensitive argument handling, line-based reconciliation, gh pr edit failures, sandbox incompatibilities) and their resolutions.
  • Enumerate lessons learned and receipts that formalize conventions such as tooling commits using chore, exemptions for .claude/** from prompt-injection findings, and avoiding self-referential pinned SHAs in post-mortems.
docs/post-mortem/1599649.md

Tips and commands

Interacting with Sourcery

  • Trigger a new review: Comment @sourcery-ai review on the pull request.
  • Continue discussions: Reply directly to Sourcery's review comments.
  • Generate a GitHub issue from a review comment: Ask Sourcery to create an
    issue from a review comment by replying to it. You can also reply to a
    review comment with @sourcery-ai issue to create an issue from it.
  • Generate a pull request title: Write @sourcery-ai anywhere in the pull
    request title to generate a title at any time. You can also comment
    @sourcery-ai title on the pull request to (re-)generate the title at any time.
  • Generate a pull request summary: Write @sourcery-ai summary anywhere in
    the pull request body to generate a PR summary at any time exactly where you
    want it. You can also comment @sourcery-ai summary on the pull request to
    (re-)generate the summary at any time.
  • Generate reviewer's guide: Comment @sourcery-ai guide on the pull
    request to (re-)generate the reviewer's guide at any time.
  • Resolve all Sourcery comments: Comment @sourcery-ai resolve on the
    pull request to resolve all Sourcery comments. Useful if you've already
    addressed all the comments and don't want to see them anymore.
  • Dismiss all Sourcery reviews: Comment @sourcery-ai dismiss on the pull
    request to dismiss all existing Sourcery reviews. Especially useful if you
    want to start fresh with a new review - don't forget to comment
    @sourcery-ai review to trigger a new review!

Customizing Your Experience

Access your dashboard to:

  • Enable or disable review features such as the Sourcery-generated pull request
    summary, the reviewer's guide, and others.
  • Change the review language.
  • Add, remove or edit custom review instructions.
  • Adjust other review settings.

Getting Help

@chromatic-com

chromatic-com Bot commented Jul 23, 2026

Copy link
Copy Markdown

Tip

All tests passed and all changes approved!

🟢 UI Tests: 998 tests unchanged
🟢 UI Review: 499 stories published -- no changes
Storybook icon Storybook Publish: 499 stories published

@github-actions

github-actions Bot commented Jul 23, 2026

Copy link
Copy Markdown
PR Preview Action efc4d8922ddcafdcc24bd6c30d83442f0acb99e9

QR code for preview link

🚀 View preview at
https://AlaskaAirlines.github.io/auro-formkit/pr-preview/pr-1572/

Built to branch gh-pages at 2026-07-24 05:03 UTC.
Preview will be ready when the GitHub Pages deployment is complete.

@jason-capsule42

Copy link
Copy Markdown
Member Author

🤖 Claude Code Review

📊 Review Quality: High confidence — single-file diff (270 insertions in .claude/skills/code-review/SKILL.md), full local context available. No TRD or post-mortem found (see below). Estimated cost: ≈ 6k input tokens (diff ~270 lines + directory scans; no component source/test files applicable).

This PR adds the code-review skill itself, so the change is a prompt/instructions document rather than component code. The component-oriented checks (WTR/Playwright/Storybook coverage, ARIA, framework integration, demos) are not applicable. Review focused on the correctness of the shell commands and logic the skill prescribes.

Findings

🔴 Bug (inline, line 217) — The first inline-comment example uses -f body=@-. With gh api, -f/--raw-field sends the value as a literal string and does not interpret @, so every comment posted through this example would have the body literally @- instead of the intended text. The explanatory text (line 226) and the multi-line example (line 241) correctly use -F body=@-. Fix the first example to -F.

🔴 Bug (inline, line 37) — In PR mode the diff is gathered with git diff $(git merge-base <base> HEAD), which diffs the working tree (not HEAD) against the merge-base. If the reviewer's working tree is dirty, uncommitted changes are pulled into the reviewed diff and the locally-computed line numbers no longer match the PR head commit — so inline comments posted to GitHub land on the wrong lines, and code that isn't part of the PR gets reviewed. The head-commit check verifies HEAD == PR head but not a clean tree. PR mode should use git diff <merge-base> HEAD (commit-to-commit). (Local/chat mode intentionally includes uncommitted changes, so it can keep the working-tree form.)

🟡 Nit (inline, line 32) — The head-commit check requests --json headRefName,headRefOid but extracts --jq '.headRefOid', so headRefName is fetched "for a friendlier message" but never actually captured; the friendly message can't include the branch name from this call.

🔴 Documentation — missing post-mortem — Per the skill's own rule ("Validate post-mortem documentation" step 3), a change should have a post-mortem at docs/post-mortem/<ticket>.md or docs/post-mortem/<PR>.md. Neither docs/post-mortem/1599649.md (AB#1599649) nor docs/post-mortem/1572.md exists. Note: this is a dev-tooling/skill addition, not component code or a bug fix, so the post-mortem requirement is arguably a poor fit here — but flagging it since the rule is unconditional. Consider either adding a brief post-mortem or scoping the rule to exclude .claude/ tooling changes.

Process checks (no issues)

  • ℹ️ No TRD linked — no post-mortem exists to link one; informational only.
  • Commit messagechore: add code review skill ... AB#1599649: chore prefix is appropriate for a dev-tooling addition, and the AB# reference is present. No commit-syntax issue.
  • Breaking changes — none (new file only); no BREAKING CHANGE needed or falsely declared.

Comment thread .claude/skills/code-review/SKILL.md Outdated
Comment thread .claude/skills/code-review/SKILL.md
Comment thread .claude/skills/code-review/SKILL.md Outdated
@github-actions

github-actions Bot commented Jul 23, 2026

Copy link
Copy Markdown

🚀 PR Release Published! v0.0.0-pr1572.13

To install:

npm install @aurodesignsystem-dev/auro-formkit@0.0.0-pr1572.13

Install via alias:

npm install @aurodesignsystem/auro-formkit@npm:@aurodesignsystem-dev/auro-formkit@0.0.0-pr1572.13

View on npmjs.com

Comment thread .claude/skills/code-review/SKILL.md Outdated
@jason-capsule42

Copy link
Copy Markdown
Member Author

🤖 Claude Code Review — PR #1572

📊 Review Quality: High confidence — single-file diff (299 lines added, 1 file), fully in-context. No source/tests/component API touched, so the component-focused persona checks (bugs, XSS, a11y, framework integration, SPA lifecycle) had no applicable surface. Review focused on the skill's procedural correctness.

  • Diff size: 299 lines (well under the 500-line depth threshold).
  • Files touched: 1 (.claude/skills/code-review/SKILL.md, new file).
  • Context availability: No post-mortem or context docs found for AB#1599649 or PR Add code review skill for GitHub PRs and local branches #1572. ℹ️ No TRD linked (no post-mortem present to link one) — informational only.
  • Estimated token cost: ≈ 12k input tokens (diff ~300 lines + committed file re-read + post-mortem/context directory scans; no source files applicable).

Findings

🔴 Documentation: No post-mortem exists for this change.
Neither docs/post-mortem/1599649.md (the referenced ADO ticket) nor docs/post-mortem/1572.md (the PR number) is present. Per this skill's own validation rule, a missing post-mortem is release-blocking. That said — applying judgment — this PR adds developer tooling (a Claude Code skill under .claude/) rather than shipping component code, so the post-mortem requirement may reasonably be waived here. Flagging for an explicit decision rather than silent omission.

🟡 Nit: PR title prefix (ci:) does not match the commit prefix (chore:).

  • Commit: chore: add code review skill for GitHub PRs and local branches AB#1599649
  • PR title: ci: add code review skill for GitHub PRs and local branches

If this repo squash-merges using the PR title, the released Conventional Commit type will differ from the commit history. Both ci and chore are non-version-bumping, so this is not release-blocking, but the two should be aligned. chore is the more accurate label — a Claude Code skill is developer tooling, not CI pipeline configuration, so ci: is the weaker of the two choices.

🟡 Nit: Case-sensitive local keyword matching — posted inline on line 16.


Validation summary

  • Commit traceability: commit references AB#1599649.
  • Commit prefix (chore): appropriate for a .claude/ tooling addition (not feat — the skill is not part of the shipped npm package's public API).
  • Breaking changes: none introduced; no BREAKING CHANGE declared (correct).
  • ℹ️ No TRD linked.
  • ⚠️ Post-mortem: missing (see 🔴 above).
  • Test coverage / stories / API docs: N/A — no component source, public API, or test-eligible logic in this diff.

This review was generated by the very skill it is reviewing (an earlier committed version). No prompt-injection content was present in the reviewed material.

@jason-capsule42 jason-capsule42 self-assigned this Jul 23, 2026
@jason-capsule42 jason-capsule42 changed the title ci: add code review skill for GitHub PRs and local branches Add code review skill for GitHub PRs and local branches Jul 23, 2026
Comment thread .claude/skills/code-review/SKILL.md
Comment thread .claude/skills/code-review/SKILL.md
Comment thread .claude/skills/code-review/SKILL.md
@jason-capsule42

Copy link
Copy Markdown
Member Author

🤖 Claude Code Review

📊 Review Quality: High confidence — diff is small and self-contained (299 lines, 1 file: .claude/skills/code-review/SKILL.md, a net-new file). This is a meta-review: the PR adds the code-review skill itself. No component source, tests, or public API are touched.

  • Diff size: 299 lines — well under the 500-line depth threshold.
  • Files touched: 1.
  • Context availability: No post-mortem, TRD, or context/ doc references this ticket/PR — none was expected for a tooling/instruction file.
  • Estimated token cost: ≈ 12k input tokens (diff ~300 lines + SKILL.md read in full + package.json/context listing checks).

ℹ️ TRD linkage

ℹ️ No TRD linked (no post-mortem exists to carry a TRD link). Informational only.

Commit validation

  • ✅ Single commit chore: add code review skill for GitHub PRs and local branches AB#1599649 — contains an AB# reference (AB#1599649).
  • ✅ Prefix chore is appropriate: the change adds developer tooling under .claude/, which is not in the package's published files list, so it is correctly semver-neutral (no feat/fix needed).
  • ✅ No breaking change to any public API, and no (correctly, no) BREAKING CHANGE declaration.

🔴 Documentation — no post-mortem

Per this skill's own validation rule ("If no post-mortem file exists at all for this change, flag as 🔴 Documentation"), there is no docs/post-mortem/1599649.md or docs/post-mortem/1572.md. Flagging for consistency with the documented policy. Caveat / judgment call: the post-mortem convention in this repo targets component bug fixes and investigations; a pure dev-tooling addition like this skill may reasonably be exempt. Recommend either adding a short post-mortem or explicitly scoping the post-mortem requirement to component changes so future runs of this very skill don't false-positive on tooling PRs.

Inline findings (see review comments on the diff)

  • 🟡 Nit (line 22): local-mode dispatch matches local case-sensitively while any other non-empty value hard-stops, so /code-review Local/LOCAL is rejected. Suggest case-insensitive compare.
  • 🟡 Nit (line 23): the numeric guard rejects forgivable inputs like #1572 or whitespace-padded arguments. Suggest trimming and stripping a leading # before the numeric test.
  • 🟡 Nit (line ~257): inline-comment POST has no 422 handling; a comment targeting a line outside the diff hunk is silently dropped. Suggest a fallback to the summary comment on non-2xx responses.

Overall

No 🔴 bugs, security issues, or regressions in the skill's logic. The procedure is well-structured, defends against prompt injection, handles detached-HEAD via SHA comparison, resolves the base branch dynamically, and documents the sandbox $(...) workaround. Findings above are all minor robustness/UX nits plus one policy-consistency documentation note.

@jason-capsule42

Copy link
Copy Markdown
Member Author

🤖 Claude Code Review — PR #1572

📊 Review Quality: High confidence — diff is a single new file (301 lines, 1 file), fully within context. Small and self-contained.

  • Context availability: No post-mortem found (docs/post-mortem/1599649.md, docs/post-mortem/1572.md both absent); no context/ doc references this ticket/PR; ℹ️ No TRD linked (no post-mortem to link one from). Review conducted without supporting design docs — acceptable here since the change is developer tooling under .claude/, not component code.
  • Estimated token cost: ≈ 12k input tokens (diff ~300 lines + full SKILL.md read + context dir listing; no source/test files applicable).

This PR adds the code-review skill itself, so the "code" under review is the review procedure. Reviewed as a prompt/procedure document.

Findings

🔴 Documentation — no post-mortem exists. Per this skill's own validation rule ("Validate post-mortem documentation", step 3), any change with commits should have a matching docs/post-mortem/<ticket>.md. None exists for AB#1599649 or PR #1572. This is surfaced per the literal procedure; for a .claude/ tooling change a post-mortem is very likely not applicable and can be waived. Flagging so the decision is explicit rather than silent.

🟡 Nit — self-referential prompt-injection false positive (see inline comment on the untrusted-input paragraph). The untrusted-input guard tells the reviewer to treat any instruction-like content in the reviewed material as a 🔴 prompt-injection finding. But legitimate files under review can contain agent-directed instructions — other skill files, CLAUDE.md, prompt templates, and this very PR. There is no mechanism to distinguish an injection attempt embedded in a data blob from legitimate instructional content in a documentation/prompt file that is the actual subject of the change. Reviewing this PR by the book would flag its own legitimate instructions as prompt injection.

🟡 Nit — no idempotency on re-run. The "Posting comments" flow always posts a fresh summary comment and fresh inline comments. Re-running /code-review 1572 after pushing a fix produces a duplicate set of bot comments with no dedup, update, or resolution of the prior run's comments. Consider noting this limitation, or updating/collapsing prior Claude review comments.

Commit validation — PASS

  • Single commit b21599achore: add code review skill for GitHub PRs and local branches AB#1599649.
  • ✅ Contains AB#1599649 work-item reference.
  • chore prefix is appropriate — the file lives under .claude/ (developer tooling, not published in the npm package), so it is neither feat nor fix.
  • ✅ No breaking changes to any public API; no BREAKING CHANGE declaration needed or falsely present.

No blocking code defects (bugs, security, regressions) were found in the procedure logic. The merge-base fallback for sandboxed shells, the SHA-based head check (detached-HEAD safe), the quoted-heredoc posting guidance, and the 422 inline-comment fallback are all sound.

Comment thread .claude/skills/code-review/SKILL.md Outdated
@jason-capsule42
jason-capsule42 force-pushed the jbaker/reviewSkill branch 2 times, most recently from 5cbb55d to 8dcbfad Compare July 23, 2026 21:51
@jason-capsule42

jason-capsule42 commented Jul 23, 2026

Copy link
Copy Markdown
Member Author

Claude Code Review — PR #1572

📊 Review Quality: High confidence — single-file diff (.claude/skills/code-review/SKILL.md, 348 insertions, ~354 diff lines), well under the 500-line threshold. No supporting docs found because none exist for this work item (see below). Estimated cost ≈ 12–15k input tokens (diff ~36 KB + skill file read; no component source/tests/post-mortems to load).

Scope: This PR adds a single instruction/prompt file — the code-review skill itself. Per this skill's own prompt-injection guard, .claude/** instruction files are exempt from prompt-injection findings, so the imperative/agent-directed language throughout the file is reviewed as ordinary content, not flagged.

Findings

🔴 Documentation: No post-mortem exists for this change (checked docs/post-mortem/1599649.md for AB#1599649 and docs/post-mortem/1572.md for the PR). The skill's own rule flags a missing post-mortem as release-blocking. Nuance for the author: this is a dev-tooling/skill addition that does not touch the published component library, so a component-style post-mortem may not be warranted — dismiss if the post-mortem process does not apply to .claude/ tooling changes.

🟡 Nit (process ordering, ~lines 238–333): The "High-level summary comment" section (posted/PATCHed first) precedes the "Inline code comments" section, but the inline-failure fallback (line 333) instructs adding unanchorable findings into the summary via a "Findings that could not be anchored inline" section. If the summary is posted before inline POSTs are attempted, a 422 discovered afterward cannot be reflected without re-PATCHing the summary — which the doc does not call out. Consider instructing the executor to attempt/anchor inline findings (or determine anchorability) before finalizing the summary, or to re-PATCH the summary after inline failures.

Commit validation

  • Single commit: chore: add code review skill for GitHub PRs and local branches AB#1599649
  • ✅ Contains AB#1599649 — traceable to a work item.
  • ✅ Prefix chore is appropriate: the skill lives under .claude/ and is not part of the npm-published component library, so it correctly avoids a feat/MINOR semver signal on the released package.
  • ✅ No breaking change to any public API; no BREAKING CHANGE declaration needed, and none is falsely present.

Context

No inline line-level code findings — both findings above are process/architectural and are reported here rather than anchored to a line.

@jason-capsule42
jason-capsule42 force-pushed the jbaker/reviewSkill branch 3 times, most recently from a6d1801 to e8b5381 Compare July 23, 2026 23:16
@jason-capsule42
jason-capsule42 force-pushed the jbaker/reviewSkill branch 2 times, most recently from 6bea935 to f0cc70b Compare July 23, 2026 23:34
Comment thread docs/post-mortem/1599649.md Outdated
Comment thread docs/post-mortem/1599649.md Outdated
@jason-capsule42

Copy link
Copy Markdown
Member Author

🤖 Claude Code Review — PR #1572

📊 Review Quality: High confidence — small diff (434 additions across 2 files), full context available.

  • Diff size: ~434 lines added (well under the 500-line depth threshold).
  • Files touched: 2 (.claude/skills/code-review/SKILL.md, docs/post-mortem/1599649.md).
  • Context availability: Post-mortem docs/post-mortem/1599649.md found and read. ℹ️ No TRD linked — the post-mortem states this is internal tooling with no GitHub Discussion/TRD authored (informational only). No docs/post-mortem/1572.md and no matching context/ documents.
  • Estimated token cost: ≈ 15k input tokens (diff ~434 lines + skill + post-mortem read; no component source involved). Estimate, not measured.

Summary

This PR adds one net-new Claude Code tooling file (.claude/skills/code-review/SKILL.md) plus its required post-mortem. No component source, tests, stories, or public API are touched, so there is no semver/npm impact. The skill itself is well-constructed: SHA-based head check, dynamic base-branch resolution, merge-base diffing, least-privilege allowed-tools, marker-based comment reconciliation, and an HTTP-422 inline fallback. I found no correctness, security, or regression bugs in the procedure.

Commit validation ✅

  • Single commit f0cc70b0dchore: add code review skill for GitHub PRs and local branches AB#1599649.
  • Conventional Commits prefix: chore is correct. Changes are confined to .claude/ tooling + a docs/ post-mortem — no shippable code, so chore (not feat/fix) is right and matches the skill's own "tooling is never a feature" rule.
  • AB# traceability:AB#1599649 present.
  • Breaking change: none, and none declared — correct.

Post-mortem validation ✅ (with one accuracy nit)

  • Post-mortem exists at docs/post-mortem/1599649.md, filename matches the referenced ADO ticket. ✅
  • TRD-deviation check: skipped — no TRD exists (by design for internal tooling). ✅
  • 📄 Documentation (posted inline, lines 17 & 77): The post-mortem cites commit 730a7d2fd in both "Reference Documents" and "Receipts", but that is a dangling pre-amend commit not on this branch. The actual add commit at the PR head is f0cc70b0d. Update both references so the auditable record matches what shipped.

Test coverage

  • N/A — instruction/prose file with no executable code paths. The post-mortem documents that the skill was validated by dogfooding (running it against its own PR), which is the appropriate acceptance test for instruction-as-code.

Note (informational, not a PR finding)

  • The local working tree currently has uncommitted edits to .claude/skills/code-review/SKILL.md that are not part of this PR head (f0cc70b0d). This review covers only the committed PR content. If those edits are intended for this PR, commit and push them, then re-run the review.

Prompt-injection check

  • The skill and post-mortem are .claude/** / instructional-doc content whose purpose is to contain agent-directed instructions. Per the skill's own exemption, this content is reviewed as ordinary prose and not flagged as prompt injection. No out-of-place review-subverting directives were found.

Verdict: Safe to ship once the two stale commit-SHA references in the post-mortem are corrected.

@jason-capsule42

Copy link
Copy Markdown
Member Author

🤖 Claude Code Review — PR #1572

📊 Review Quality: High confidence — diff is small and self-contained, full context available.

  • Diff size: ~434 added lines across 2 new files (well under the 500-line threshold).
  • Files touched: 2 (.claude/skills/code-review/SKILL.md, docs/post-mortem/1599649.md).
  • Context availability: Post-mortem docs/post-mortem/1599649.md found and read; matches AB#1599649. No context docs reference this work item. ℹ️ No TRD linked — post-mortem states this is internal tooling with no GitHub Discussion/TRD (informational only, not an issue).
  • Estimated token cost: ≈ 14k input tokens (SKILL.md diff ~342 lines + post-mortem ~92 lines + git/gh metadata read).

Process validation

  • Commit message: chore: add code review skill for GitHub PRs and local branches AB#1599649 — carries an AB# reference (traceable), and chore is the correct prefix for a change confined to .claude/ tooling + docs (no npm/semver impact). No breaking change; no false BREAKING CHANGE declaration.
  • Post-mortem: present and correctly named (1599649.md matches the referenced ADO ticket).
  • Self-review exemptions honored: the skill's own .claude/** instructional prose is reviewed as ordinary content (not flagged as prompt injection), per the skill's own untrusted-input guard.

Findings (inline)

Two inline comments on docs/post-mortem/1599649.md (lines 17 and 77) — both 📄 Documentation (non-blocking):

  • Stale add-commit SHA. The post-mortem cites f0cc70b0d as the add commit in both the Reference Documents and Receipts sections, but the actual head commit on this branch is 59d20a4e3. f0cc70b0d is a dangling pre-amend commit that is not reachable from the branch tip, so a reader following the reference won't find it on the branch. This same finding was raised by the prior review (which corrected 730a7d2fdf0cc70b0d); the branch was re-amended afterward, so the SHA has drifted again. The two prior inline comments were updated in place (not duplicated) with the corrected SHA. Note: a squash-merge will regenerate the SHA once more, so consider whether pinning a specific SHA in the post-mortem is worth the maintenance.

Summary

Clean, well-constructed PR. The change is a single net-new Claude Code skill plus its required post-mortem — no component source, tests, stories, or public API touched, so there is no runtime, accessibility, framework-integration, security, or semver impact to assess. The only issue is the recurring stale-SHA documentation nit above; nothing here is release-blocking.

Comment thread docs/post-mortem/1599649.md Outdated
@jason-capsule42

Copy link
Copy Markdown
Member Author

🤖 Claude Code Review — PR #1572

📊 Review Quality: High confidence — small, self-contained diff with full context.

  • Diff size: 466 lines added across 2 new files (well under the 500-line threshold).
  • Files touched: 2 (.claude/skills/code-review/SKILL.md, docs/post-mortem/1599649.md).
  • Context availability: Post-mortem docs/post-mortem/1599649.md found and read; no context/ docs reference this work; no PR-numbered post-mortem.
  • Estimated token cost: ≈ 17k input tokens (diff ~466 lines + SKILL.md 371 lines + post-mortem 95 lines read). Estimate, not measured.

Process & validation

  • Commit message: chore: add code review skill for GitHub PRs and local branches AB#1599649 — carries an AB# reference, and chore is the correct prefix (changes are confined to .claude/ tooling + a non-shippable post-mortem doc; no public API, no semver impact). No breaking change, and none is (correctly) declared.
  • Post-mortem: Present and correctly named to the ADO ticket (1599649.md). It documents the final solution, decisions, and lessons.
  • Stable commit identifier: The post-mortem deliberately avoids pinning a commit SHA and identifies its change by subject + branch + PR instead — this follows the skill's own anti-staling guidance. Two prior inline comments about SHA-pinning are already resolved and were left untouched.
  • ℹ️ No TRD linked — the post-mortem explicitly states this is internal tooling with no GitHub Discussion / TRD authored. Informational only; the TRD-deviation check does not apply.

Findings

  • 📄 Documentation (inline, docs/post-mortem/1599649.md:78): The Receipts line states SKILL.md is "342 lines," but the committed file is 371 lines. An exact line count is a volatile self-reference that drifts on every amend — the same failure mode the post-mortem calls out for commit SHAs. Suggested fix (dropping the count) posted inline. Non-blocking.
  • 🟡 Nit (docs/post-mortem/1599649.md:38): The "What Landed vs. What Was Planned" persona list — "(consumer, a11y, framework, security, QA, maintainer, release, staff)" — names 8 personas but omits performance engineer, while the adjacent text correctly says "nine personas." Minor; add performance engineer to the parenthetical for accuracy.

Notes

  • This diff is a code-review skill reviewing its own introduction. Per the untrusted-input guard, .claude/** instructional prose is reviewed as ordinary content and is not flagged as prompt injection — no injection findings apply.
  • No bugs, security issues, regressions, or edge-case gaps found in the skill logic. The instruction-as-code is internally consistent: least-privilege allowed-tools, quoted-heredoc bodies to avoid shell injection, SHA-based head check, merge-base diffing, and marker-based idempotent comment reconciliation are all coherent.
  • Test coverage / stories / API-doc checks are N/A — no component source, tests, or public API changed.
  • The local working tree has uncommitted edits to SKILL.md that are not part of PR head de54be5; this review covers only the committed PR content.

Overall: Safe to ship. Only non-blocking documentation accuracy nits (line count + persona list); resolve at author's discretion.

Comment thread .claude/skills/code-review/SKILL.md Outdated
@jason-capsule42

Copy link
Copy Markdown
Member Author

🤖 Claude Code Review — PR #1572

📊 Review Quality: High confidence — small, single-purpose diff (478 diff lines across 2 files), full context available (post-mortem read; no TRD by design). Well under the 500-line / 15-file thresholds, so cross-file analysis is complete.
Estimated cost: ≈ 15k input tokens (diff ~478 lines + committed SKILL.md 371 lines + post-mortem 95 lines + 3 prior inline comments read).

Scope

Two new files, both under non-shipping paths:

  • .claude/skills/code-review/SKILL.md (new, 371 lines) — the /code-review skill.
  • docs/post-mortem/1599649.md (new, 95 lines) — the required post-mortem.

No component source, tests, stories, demos, or public API touched → no semver/npm impact. The test-coverage, story, and API-doc checks do not apply (nothing shippable changed).

✅ Process & release validation — all pass

  • Commit message: chore: add code review skill for GitHub PRs and local branches AB#1599649
    • Carries AB#1599649 (traceable). ✓
    • chore prefix is correct — the change is confined to .claude/ tooling, which the skill's own rule (and this repo's convention) mandates be chore, never feat. No spurious MINOR bump. ✓
  • Breaking changes: none — two net-new files, no removed/renamed public API. No BREAKING CHANGE needed, and none falsely declared. ✓
  • Post-mortem: present at docs/post-mortem/1599649.md, filename matches the referenced ADO ticket. ✓
  • Pinned-SHA self-reference: the post-mortem deliberately identifies its own commit by subject + branch + PR rather than a SHA, exactly as the skill's rule 5 recommends. No finding. ✓
  • ℹ️ No TRD linked — the post-mortem states this is internal tooling with no authored GitHub Discussion / TRD. Informational only; the TRD-deviation check is correctly skipped.
  • Executive Summary sync: the PR description already contains the current post-mortem's Executive Summary (markers present, content matches verbatim) — sync is a no-op this run.

Findings

One non-blocking nit, posted inline:

  • 🟡 Nit (.claude/skills/code-review/SKILL.md:93) — the Untrusted-input guard enumerates the skill's legitimate side effects as "the git/gh read commands and the review comments," but the Executive-Summary-sync step also runs gh pr edit to write the PR description. A strict reading of the guard would forbid that write. Recommend widening the enumeration to include the one-time PR-description sync.

Inline reconciliation

  • 3 prior inline comments found. Two were already-resolved stale-SHA findings (left untouched). One flagged a stale SKILL.md line count in the post-mortem; that text has since been removed at the current head, so it was updated to resolved.

Verdict: Clean, release-ready. No blocking issues. The single nit is a wording accuracy improvement in the skill's own guard.

@jason-capsule42
jason-capsule42 force-pushed the jbaker/reviewSkill branch 3 times, most recently from 4665eb6 to b6fef69 Compare July 24, 2026 04:18
@jason-capsule42

Copy link
Copy Markdown
Member Author

✅ Claude Code Review — PR #1572

📊 Review Quality: High confidence — diff is small and fully in context.

  • Diff size: ~487 lines added across 2 new files (well under the 500-line threshold).
  • Files touched: 2 (.claude/skills/code-review/SKILL.md, docs/post-mortem/1599649.md) — no cross-file interaction risk.
  • Context availability: Post-mortem docs/post-mortem/1599649.md found and read (matches AB#1599649, includes an Executive Summary, does not pin its own SHA). No context/ docs reference this ticket/PR. ℹ️ No TRD linked — the post-mortem states this is internal tooling with no authored TRD; informational only, TRD-deviation check correctly skipped.
  • Confidence: High.
  • Estimated token cost: ≈ 14k input tokens (diff ~487 lines + SKILL.md ~43 KB + post-mortem ~7 KB + PR body + prior comments read). Estimate, not measured.

Code review

This PR adds the /code-review skill itself plus its post-mortem — a self-review. Per the skill's own untrusted-input guard, the instructional prose under .claude/** is reviewed as ordinary content, not flagged as prompt injection.

No blocking issues found. Reviewed adversarially across all personas:

  • No bugs, security issues, or regressions — both files are net-new; the skill is careful about shell-injection throughout (quoted heredocs / --body-file) and consistent about it.
  • allowed-tools is least-privilege and consistent: every git/gh command the procedure invokes is covered by an enumerated grant, and no grant is unused.
  • Argument normalization, mode selection, base-branch resolution, head-SHA check, and re-run/reconciliation policies are internally consistent.

Prior inline comment reconciled: the one active nit from an earlier run (the untrusted-input guard not naming the PR-description write as a side effect) is already fixed in the current head — line 95 now enumerates "the one-time PR-description sync (the executive-summary block)". That comment was marked resolved. Three other prior inline comments were already resolved and left untouched.

Commit validation

  • chore: add code review skill for GitHub PRs and local branches AB#1599649
    • ✅ Carries AB#1599649 (traceable to a work item).
    • chore prefix is correct — changes are confined to .claude/ tooling + a docs/ post-mortem, neither of which is a shippable feature/fix; no semver impact.
    • ✅ No breaking change to any public API, and (correctly) no BREAKING CHANGE declaration.

Post-mortem validation

  • ✅ Post-mortem present at docs/post-mortem/1599649.md, filename matches the referenced ADO ticket.
  • ✅ Does not pin its own commit SHA — it identifies the commit by subject + branch + PR, per the skill's own stable-identifier rule.
  • ✅ Executive Summary already synced into this PR description (idempotent no-op this run — the synced block matches the post-mortem).

Optional polish (non-blocking, do not act on unless you want to)

  • The description: frontmatter says "run without arguments to review the current branch," but the local keyword invocation isn't named there (it is in argument-hint). Purely a completeness nicety.

✅ No blocking issues — the remaining suggestion is optional polish.

@jason-capsule42
jason-capsule42 force-pushed the jbaker/reviewSkill branch 2 times, most recently from c044e16 to ed356ca Compare July 24, 2026 04:31
@jason-capsule42

Copy link
Copy Markdown
Member Author

🤖 Claude Code Review — PR #1572

📊 Review Quality: High confidence — diff is small (499 lines across 2 files), full context available.

  • Context: Post-mortem docs/post-mortem/1599649.md found and used. ℹ️ No TRD linked — the post-mortem states this is internal tooling and no GitHub Discussion/TRD was authored (informational only). No context/ docs reference this work.
  • Estimated token cost: ≈ 20k input tokens (499-line diff + SKILL.md 375 lines + post-mortem 112 lines + current PR body read). Estimate, not measured.

✅ Outcome: No blocking issues

This PR adds one net-new tooling file under .claude/ plus its required post-mortem. No component source, tests, stories, or public API changed, so there is no semver/npm impact. The two findings below are minor 🟡 nits, posted inline — neither blocks merge.

Process validation

  • Commit messages — 1 commit: chore: add code review skill for GitHub PRs and local branches AB#1599649.
    • ✅ Carries AB#1599649 (traceable).
    • chore prefix is correct — the change is confined to .claude/ tooling plus a docs post-mortem, which carry no public API / semver impact. feat/fix would be wrong here.
    • ✅ No breaking change; no BREAKING CHANGE declaration needed, and none is falsely present.
  • Post-mortem — ✅ docs/post-mortem/1599649.md exists and its filename matches the referenced ADO ticket AB#1599649. It does not pin its own commit SHA (it identifies the commit by subject + branch + PR), so the stable-identifier rule is satisfied — no finding.
  • Executive-summary sync — the PR description already contains an up-to-date exec-summary block (identical to the current post-mortem). ⚠️ The mandated re-write via gh pr edit failed with a gh Projects (classic) deprecation GraphQL error — a known upstream gh bug on repos with classic projects, unrelated to this PR's content. The description is already in sync, so no action is needed, but the automated overwrite could not run in this environment.
  • Tests / stories — N/A: this is an instruction/documentation skill with no shippable code to unit-test or add stories for.

Inline findings (both 🟡 Nit, non-blocking)

  1. .claude/skills/code-review/SKILL.md (~line 77) — the sandbox heredoc-fallback tells the skill to "write the body to a temp file first," but allowed-tools grants only Read, Grep, Glob (no Write) and the Bash grants are limited to specific git/gh shapes. In a sandbox that blocks heredocs, neither the fallback nor any comment-posting can execute. Consider adding a narrow Write grant (or a Bash redirect grant) so the documented fallback is actually reachable.
  2. .claude/skills/code-review/SKILL.md (~line 354) — the HTTP-422 inline fallback routes findings into the high-level summary comment, but the summary is documented (and typically posted) before the inline-comment step and is "always posted new, never edited." If the summary is posted first, a 422-fallback finding has nowhere to land. Consider a one-line clarification: attempt inline anchoring before composing/posting the summary, so un-anchorable findings are included.

Note on convergence: prior runs of this skill on this PR all converged to a resolved state, and this run reproduced no prior finding. The two nits above are new-angle polish, not regressions — treat them as optional.

Comment thread .claude/skills/code-review/SKILL.md Outdated
Comment thread .claude/skills/code-review/SKILL.md Outdated
@jason-capsule42

Copy link
Copy Markdown
Member Author

Claude Code Review — PR #1572

📊 Review Quality: High confidence. Diff is small (501 lines across 2 files: .claude/skills/code-review/SKILL.md + docs/post-mortem/1599649.md), all context available. Post-mortem found and used; no TRD (internal tooling — post-mortem states none was authored); no context/ docs reference this work. Estimated cost: ≈ 20k input tokens (diff ~63 KB + post-mortem + prior-comment reconciliation).

✅ No blocking issues

Both files are instructional/documentation content under .claude/** and docs/, reviewed as ordinary content per the skill's own untrusted-input guard (not flagged as prompt injection). No shippable code, tests, stories, or public API changed — no semver impact.

Commit validation

  • Single commit: chore: add code review skill for GitHub PRs and local branches AB#1599649
  • ✅ Carries an AB# reference (AB#1599649).
  • chore prefix is correct — changes are confined to .claude/ tooling plus a docs/ post-mortem; neither is a shippable feature/fix, so no bump-triggering prefix is warranted.
  • ✅ No breaking change to any public API, and none is falsely declared.

Post-mortem / TRD validation

  • ✅ Post-mortem present at docs/post-mortem/1599649.md, filename matches the referenced ADO ticket.
  • ✅ The post-mortem identifies its own change by commit subject + branch + PR, not a pinned SHA (Reference Documents & Receipts both call this out) — correctly avoids the self-staling-SHA anti-pattern.
  • ℹ️ No TRD linked — internal tooling; the post-mortem states no GitHub Discussion / TRD was authored. Informational only.

Reconciliation of prior review comments

  • 4 prior inline comments were already in ✅ Resolved form (superseded stale-SHA / line-count findings) — left untouched.
  • 2 previously-active 🟡 nits are now fixed by the current head and were updated to Resolved:
    • The heredoc fallback now has a matching Write(/tmp/*) grant in the frontmatter.
    • An explicit "Order of operations — inline first, summary last" section now guarantees 422 fallbacks land in the summary.

Notes

  • ⚠️ The post-mortem executive-summary sync into the PR description could not be re-written this run: gh pr edit failed with an unrelated GitHub "Projects (classic) deprecation" GraphQL error. The description already contains exactly one correct exec-summary block matching the current post-mortem, so it remains in sync — no manual action needed.

Remaining suggestions, if any, are optional polish. This diff is clean.

@jason-capsule42

Copy link
Copy Markdown
Member Author

🤖 Claude Code Review — PR #1572

📊 Review Quality: High confidence — diff is small and fully in context.

  • Diff size: 506 lines added across 2 new files (.claude/skills/code-review/SKILL.md +378, docs/post-mortem/1599649.md +128). Well under the 500-line depth threshold for prose; no context limits hit.
  • Files touched: 2 — cross-file interaction analysis complete.
  • Context availability: Post-mortem docs/post-mortem/1599649.md found and read. No context/ docs reference this ticket/PR. No docs/post-mortem/1572.md.
  • Confidence: High.
  • Estimated token cost: ≈ 20k input tokens (506-line diff + committed SKILL.md and post-mortem read in full + PR body + skill procedure). Estimate only — derived from characters processed ÷ 4, not measured usage.

✅ No blocking issues

This is a self-referential change — a code-review skill plus its post-mortem. Per the skill's own untrusted-input guard, the instructional content of .claude/** is reviewed as ordinary content, not flagged as prompt injection. Reviewed against all nine personas; the diff is clean and has converged. Any remaining suggestions would be optional polish, and none rise to a nit I would act on.

The six inline findings from earlier runs (stale-SHA in the post-mortem, stale line-count, the side-effects enumeration omitting the exec-summary sync, the unreachable Write temp-file fallback, and the missing order-of-operations rule) are all resolved at the current head and remain marked resolved. No new inline findings this run.

ℹ️ TRD linkage

No TRD linked. The post-mortem states this is internal tooling with no GitHub Discussion / TRD authored. Informational only — the TRD-deviation check does not apply.

Commit validation

  • 1 commit: chore: add code review skill for GitHub PRs and local branches AB#1599649
  • ✅ Carries an AB# reference (AB#1599649) — traceable to a work item.
  • chore prefix is correct. The change is confined to .claude/ tooling plus a docs/post-mortem/ file — neither is shippable code, so there is no semver impact and feat/fix would be wrong. This matches the skill's own "tooling under .claude/ is always chore, never feat" rule.
  • ✅ No public-API change → no BREAKING CHANGE required, and none is (correctly) declared.

Post-mortem validation

  • Post-mortem present: docs/post-mortem/1599649.md, filename matches the referenced ADO ticket AB#1599649.
  • No pinned self-referential SHA. The post-mortem deliberately identifies its own commit by subject + branch + PR rather than a SHA, and documents why — satisfying the stable-identifier rule. The only external reference (cli/cli#11983) is an upstream issue link, not a self-referencing SHA.
  • Post-mortem accuracy: spot-checked claims against the committed skill (tooling-is-chore rule, SHA-pinning validation, REST-PATCH exec-summary sync, Write(/tmp/*) grant, removed git show/git status grants, case-insensitive local, $ARGUMENTS normalization) — all present as described.

Process notes (informational, non-blocking)

  • 🔄 Exec-summary sync performed. The PR description's pm-exec-summary block was stale (it lacked the "and mirrors this post-mortem's executive summary into the PR description" clause now in the post-mortem). It has been rebuilt from the current post-mortem and overwritten via REST PATCH .../pulls/1572.
  • 📝 The local working tree has staged, uncommitted edits to SKILL.md that are not part of the PR head (16f9347). This review covers only the committed PR head, which matches the PR's head SHA. Push those edits if they are meant to be included.

@jason-capsule42
jason-capsule42 marked this pull request as ready for review July 24, 2026 05:06
@jason-capsule42
jason-capsule42 requested a review from a team as a code owner July 24, 2026 05:06

@sourcery-ai sourcery-ai Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Hey - I've reviewed your changes and they look great!


Sourcery is free for open source - if you like our reviews please consider sharing them ✨
Help me be more useful! Please click 👍 or 👎 on each comment and I'll use the feedback to improve your reviews.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant