/sglang-humanize-review

name: sglang-humanize-review
description: "Perform SGLang code review in the style of human maintainers by consulting the public PR review episode corpus from project start through 2026-07-27, including inline review threads, top-level PR comments, review submissions, original multilingual text, and multi-round discussions. Use when reviewing SGLang PRs, diffs, patches, or local changes for correctness, tests, performance, GPU/runtime risks, API compatibility, and maintainability."

SGLang Humanize Review

Use the maintained [source contracts](../../docs/upstream-source-contracts.md) when applying historical evidence to a current branch. The review/history corpora retain their own capture dates; they do not certify today's dispatch or numerical defaults. For kernel replacements, verify that the real model executes the candidate before treating end-to-end tests as coverage.

Overview

Use this skill when the user asks for a human-style SGLang code review or wants review feedback that resembles SGLang maintainers instead of generic linting.

Every review opens with a **PR comprehension pass**: a short change summary plus a Mermaid execution flowchart (with the PR's added/modified steps marked) so the reviewer can see how the diff actually runs before reading any findings. See [PR Comprehension Diagram](#pr-comprehension-diagram).

The bundled corpus is collected from `sgl-project/sglang` PRs from the first public PR through `2026-07-27`, intended to exclude bot/agent PR authors. The historical snapshot contains User-type bot leaks (59 `sglang-bot` PRs / 60 inline threads); its contents and counts were preserved. Future collection excludes `-bot`, `metamergebot` and `diffray` accounts. Mirror authorship is not evidence of human design intent. Public framework knowledge around this skill was refreshed on 2026-10-05; the gzip corpus itself was not recrawled in that pass, so reviews after 2026-07-27 must be read live from GitHub. The collector paginates every PR's full conversation and review history, so long multi-round discussions are captured in their entirety rather than truncated at the first 100 events. It is organized as review episodes, not just individual comments:

• `inline_review_thread`: file/path-specific GitHub pull-review comments with

`diff_hunk` context and replies grouped by thread.

• `pr_conversation`: top-level PR conversation comments, including design

discussion, requested repros, benchmark negotiation, and author follow-ups.

• `review_submission`: review summary bodies such as COMMENT and

REQUEST_CHANGES, preserving the review state.

Every episode preserves PR metadata, reviewer identity, original comment text, original comment language, timestamps, categories, and multi-round replies when GitHub exposes them. Read [references/corpus-summary.md](references/corpus-summary.md) first for coverage, counts, top paths, and category distribution. Do not paste the raw gzip corpus into context; go through the helper scripts, which read it in memory-bounded segments and return a digest.

Corpus Tools

There are two tools. **For an actual PR review, the exhaustive sweep below is mandatory** (see workflow step 3); the first-N query tool is only for follow-up drill-downs.

Exhaustive sweep + synthesis (run this first, for every review)

`summarize_sglang_review_corpus.py` scans the **whole** corpus in memory-bounded segments, folds **every** relevant thread into the aggregate (not just the first N), and retains only the requested top relevance-ranked review opinions. Pass every touched path and the PR's risk keywords; `--path` and `--query` are repeatable and OR-combined.

python3 skills/sglang-humanize-review/scripts/summarize_sglang_review_corpus.py \
  --path python/sglang/srt/speculative --path python/sglang/srt/managers \
  --query eagle --query "cuda graph" --query verify --query logprob \
  --top 30

It reports `Scanned N threads ... matched M threads across K PRs` so coverage is explicit. Read the aggregate and the top-ranked threads, then write a short synthesis of the recurring historical review opinions before reviewing. Use `--format jsonl` to stream all matched threads when you need to read every one.

First-N lookup (follow-up drill-down only)

Search the corpus by topic, path, category, or reviewer:

python3 skills/sglang-humanize-review/scripts/query_sglang_review_corpus.py \
  --query cuda --limit 5

python3 skills/sglang-humanize-review/scripts/query_sglang_review_corpus.py \
  --path python/sglang/srt --category correctness --limit 8

python3 skills/sglang-humanize-review/scripts/query_sglang_review_corpus.py \
  --query server_args --format jsonl --limit 3

python3 skills/sglang-humanize-review/scripts/query_sglang_review_corpus.py \
  --kind pr_conversation --query benchmark --limit 5

python3 skills/sglang-humanize-review/scripts/query_sglang_review_corpus.py \
  --kind review_submission --query "request changes" --limit 5

The full corpus is:

references/sglang-review-corpus.jsonl.gz

Regenerate it only when the user asks to refresh the evidence (bump `--end-year` to the current year; the collector caps the event window at "now" and paginates each PR's full conversation/review history):

python3 skills/sglang-humanize-review/scripts/collect_sglang_review_corpus.py \
  --repo sgl-project/sglang \
  --from-beginning \
  --end-year 2026 \
  --out-dir skills/sglang-humanize-review/references

Review Workflow

1. Inspect the actual diff first.

• Use `git diff`, `gh pr diff`, or the patch supplied by the user.
• Identify changed SGLang subsystems: server args, scheduler, memory/cache,

model runner, attention backend, quantization, kernels, OpenAI API, metrics, docs, or tests. 2. Read `references/corpus-summary.md`.

• Note top review surfaces and categories that overlap with the diff.
• Check episode coverage. Inline evidence is best for file-local findings;

P