Awesome Reviewers

Verifying C++ changes

Files: .cc, .cpp, .cxx, .hh, .hpp, .hxx. Derived from 13 scanned source repositories and 148 review prompts on https://awesomereviewers.com. Page: https://awesomereviewers.com/verify/cpp/

How to use this: run every check under Run on every change. Then, for each section under Add when the change touches that describes your diff, run its checks too. Checks catch what a tool can find; then apply the listed review prompts for what tools miss (fetch each prompt’s raw URL).

Usage is the share of scanned repositories in this language that run the tool. A missing tool means no scanned repository runs one the scanner recognises: fall back to the prompts.

Run on every change

• Formatting — no tool detected in the sample. Catches: Layout drift that buries the real change in the diff.
• Linting — no tool detected in the sample. Catches: Bug-prone patterns, unused code and conventions the formatter does not cover.
• Type checking — The compiler type-checks on every build and test run; a failing build is this check failing.
• Unit and integration tests — no tool detected in the sample. Catches: Behaviour regressions on the paths the tests exercise.

Review prompts (26 in total, most discussed first):

• no braces short ifs — hyprwm/Hyprland, Code Style
• Consistency And Readability — Tencent/ncnn, Code Style
• Code for readability — opencv/opencv, Code Style
• Use descriptive semantic names — ClickHouse/ClickHouse, Naming Conventions
• Use descriptive naming — duckdb/duckdb, Naming Conventions
• Avoid unnecessary auto — llvm/llvm-project, Code Style
• Eliminate code duplication — duckdb/duckdb, Code Style
• Remove debugging artifacts — deeplearning4j/deeplearning4j, Code Style
• Consistent Semantic Identifiers — Tencent/ncnn, Naming Conventions
• Use descriptive identifiers — microsoft/terminal, Naming Conventions
• Use descriptive names — llvm/llvm-project, Naming Conventions
• maintain naming consistency — ggml-org/llama.cpp, Naming Conventions

Add when the change touches

Authentication, input handling, secrets, permissions

• Security scanning: codeql (31% of repos). Runs via GitHub Action github/codeql-action/analyze. Docs: https://github.com/github/codeql
• Secret scanning — no tool detected in the sample. Catches: Credentials and tokens committed to the repository.
• Dependency audit — no tool detected in the sample. Catches: Known-vulnerable or disallowed dependencies and licenses.

Review prompts (6 in total, most discussed first):

• validate user inputs — ClickHouse/ClickHouse, Security
• Preserve pointer authentication — dotnet/runtime, Security
• secure sensitive data handling — duckdb/duckdb, Security
• Verify cryptographic function behavior — oven-sh/bun, Security
• Buffer bounds validation — maplibre/maplibre-native, Security
• Validate by File Header — Tencent/ncnn, Security

Public APIs, signatures, error paths, nullability

• Type checking — The compiler type-checks on every build and test run; a failing build is this check failing.
• Unit and integration tests — no tool detected in the sample. Catches: Behaviour regressions on the paths the tests exercise.
• Property-based tests — no tool detected in the sample. Catches: Edge-case inputs nobody wrote a test for; invariants over generated data.

Review prompts (36 in total, most discussed first):

• Explicit error handling — ClickHouse/ClickHouse, Error Handling
• Assert before cast — oven-sh/bun, Null Handling
• prevent null dereferences — hyprwm/Hyprland, Null Handling
• Graceful Error Propagation — Tencent/ncnn, Error Handling
• Clear API contracts — opencv/opencv, API
• Check exceptions consistently — oven-sh/bun, Error Handling
• Use OpenCV error mechanisms — opencv/opencv, Error Handling
• Prevent null vulnerabilities — opencv/opencv, Null Handling
• Handle errors by severity — maplibre/maplibre-native, Error Handling
• consistent null validation — duckdb/duckdb, Null Handling
• Design thoughtful API interfaces — llvm/llvm-project, API
• Eliminate redundant null checks — llvm/llvm-project, Null Handling

Service and framework code

• Unit and integration tests — no tool detected in the sample. Catches: Behaviour regressions on the paths the tests exercise.
• Version and platform matrix: ci-matrix (23% of repos). Command seen: codeql-analyze (language: 3). Docs: https://docs.github.com/en/actions/how-tos/write-workflows/choose-what-workflows-do/run-job-variations

Algorithms, parsers, data transforms

• Property-based tests — no tool detected in the sample. Catches: Edge-case inputs nobody wrote a test for; invariants over generated data.
• Fuzzing — no tool detected in the sample. Catches: Crashes, panics and hangs on malformed input, especially in parsers and decoders.
• Mutation testing — no tool detected in the sample. Catches: Tests that keep passing whatever the code does.
• Proofs and specifications — no tool detected in the sample. Catches: Design-level bugs in protocols and algorithms, checked against a specification.

Review prompts (15 in total, most discussed first):

• Spec-aligned Algorithm Correctness — Tencent/ncnn, Algorithms
• optimize algorithmic choices — microsoft/terminal, Algorithms
• Use optimized functions — opencv/opencv, Algorithms
• explicit control flow logic — ggml-org/llama.cpp, Algorithms
• optimize algorithmic complexity — ClickHouse/ClickHouse, Algorithms
• optimize computational efficiency — hyprwm/Hyprland, Algorithms
• Abstract traversal patterns — dotnet/runtime, Algorithms
• optimize computational complexity — llvm/llvm-project, Algorithms
• avoid redundant lookups — duckdb/duckdb, Algorithms
• Reuse existing algorithms — pytorch/pytorch, Algorithms
• Numerical precision considerations — maplibre/maplibre-native, Algorithms
• avoid unnecessary allocations — facebook/react-native, Algorithms

Threads, async code, locks, shared state

• Concurrency model checking — no tool detected in the sample. Catches: Races and orderings that fail only under specific interleavings.
• Undefined-behaviour detection — no tool detected in the sample. Catches: Memory-safety and aliasing violations in unsafe code.
• Property-based tests — no tool detected in the sample. Catches: Edge-case inputs nobody wrote a test for; invariants over generated data.

Review prompts (10 in total, most discussed first):

• manage object lifetimes carefully — microsoft/terminal, Concurrency
• Protect shared state — duckdb/duckdb, Concurrency
• Enforce clear data ownership — maplibre/maplibre-native, Concurrency
• Framework synchronization practices — opencv/opencv, Concurrency
• Evaluate synchronization necessity — facebook/yoga, Concurrency
• Memory ordering matters — dotnet/runtime, Concurrency
• consistent mutex protection — ClickHouse/ClickHouse, Concurrency
• protect shared data — llvm/llvm-project, Concurrency
• weak pointer callback safety — hyprwm/Hyprland, Concurrency
• Thread-safe state transitions — oven-sh/bun, Concurrency

Network calls, retries, timeouts, protocols

• Unit and integration tests — no tool detected in the sample. Catches: Behaviour regressions on the paths the tests exercise.
• Fuzzing — no tool detected in the sample. Catches: Crashes, panics and hangs on malformed input, especially in parsers and decoders.

Review prompts (4 in total, most discussed first):

• Avoid duplicate HTTP headers — ClickHouse/ClickHouse, Networking
• Platform-agnostic network APIs — dotnet/runtime, Networking
• Validate network inputs — oven-sh/bun, Networking
• Protocol response formatting — microsoft/terminal, Networking

UI components and pages

• End-to-end browser tests — no tool detected in the sample. Catches: User flows broken across components, routing and the network.
• Linting — no tool detected in the sample. Catches: Bug-prone patterns, unused code and conventions the formatter does not cover.

Databases, migrations, caching

• Unit and integration tests — no tool detected in the sample. Catches: Behaviour regressions on the paths the tests exercise.
• Version and platform matrix: ci-matrix (23% of repos). Command seen: codeql-analyze (language: 3). Docs: https://docs.github.com/en/actions/how-tos/write-workflows/choose-what-workflows-do/run-job-variations

Review prompts (5 in total, most discussed first):

• validate before executing operations — ClickHouse/ClickHouse, Database
• validate inputs comprehensively — duckdb/duckdb, Database
• use default serialization methods — duckdb/duckdb, Migrations
• Optimize database interactions — oven-sh/bun, Database
• avoid redundant cache lookups — ClickHouse/ClickHouse, Caching

Hot paths and performance

• No tool-based check applies; rely on the prompts.

Review prompts (15 in total, most discussed first):

• Avoid unnecessary allocations — ClickHouse/ClickHouse, Performance Optimization
• Cache expensive computations — microsoft/terminal, Performance Optimization
• Unrolled SIMD Locality — Tencent/ncnn, Performance Optimization
• avoid repeated expensive operations — duckdb/duckdb, Performance Optimization
• avoid unnecessary allocations — llvm/llvm-project, Performance Optimization
• avoid expensive hot paths — hyprwm/Hyprland, Performance Optimization
• Model actual hardware costs — dotnet/runtime, Performance Optimization
• measure before optimizing — ggml-org/llama.cpp, Performance Optimization
• Optimize memory allocation patterns — opencv/opencv, Performance Optimization
• Optimize memory usage — pytorch/pytorch, Performance Optimization
• Preallocate collection capacity — maplibre/maplibre-native, Performance Optimization
• Cache repeated accesses — oven-sh/bun, Performance Optimization

Model, prompt and LLM code

• Unit and integration tests — no tool detected in the sample. Catches: Behaviour regressions on the paths the tests exercise.

Review prompts (7 in total, most discussed first):

• Optimize numerical precision — pytorch/pytorch, AI
• use model metadata — ggml-org/llama.cpp, AI
• Inference Compatibility Rules — Tencent/ncnn, AI
• Validate tensor dimensions — opencv/opencv, AI
• Actionable error messages — pytorch/pytorch, Pytorch
• AI dependency decoupling strategy — ollama/ollama, AI
• Document AI implementation references — deeplearning4j/deeplearning4j, AI

Logging, metrics, tracing

• No tool-based check applies; rely on the prompts.

Review prompts (4 in total, most discussed first):

• Use proper logging — maplibre/maplibre-native, Logging
• Guard expensive logging operations — duckdb/duckdb, Logging
• Use appropriate logging levels — deeplearning4j/deeplearning4j, Logging
• Conditional observability instrumentation — maplibre/maplibre-native, Observability

CI workflows and configuration files

• CI workflow linting — no tool detected in the sample. Catches: Broken GitHub Actions syntax, script injection, over-broad token permissions.
• File hygiene: pre-commit-hooks (15% of repos). Runs via pre-commit hook check-yaml. Autofixes. Docs: https://github.com/pre-commit/pre-commit-hooks

Review prompts (11 in total, most discussed first):

• Capability-Guarded Configuration — Tencent/ncnn, Configurations
• Dynamic configuration handling — hyprwm/Hyprland, Configurations
• Setting declaration practices — ClickHouse/ClickHouse, Configurations
• Configuration completeness validation — llvm/llvm-project, Configurations
• prefer settings over pragmas — duckdb/duckdb, Configurations
• Structure configuration options — dotnet/runtime, Configurations
• Validate before configuration generation — microsoft/terminal, Configurations
• Externalize config values — maplibre/maplibre-native, Configurations
• Use strongly typed configurations — ggml-org/llama.cpp, Configurations
• platform-aware configuration messages — facebook/react-native, Configurations
• Safe configuration definitions — facebook/yoga, Configurations

Dependencies and lockfiles

• Dependency audit — no tool detected in the sample. Catches: Known-vulnerable or disallowed dependencies and licenses.
• Lockfile consistency — no tool detected in the sample. Catches: A lockfile that no longer matches its manifest.
• Version and platform matrix: ci-matrix (23% of repos). Command seen: codeql-analyze (language: 3). Docs: https://docs.github.com/en/actions/how-tos/write-workflows/choose-what-workflows-do/run-job-variations

The tests themselves

• Mutation testing — no tool detected in the sample. Catches: Tests that keep passing whatever the code does.
• Version and platform matrix: ci-matrix (23% of repos). Command seen: codeql-analyze (language: 3). Docs: https://docs.github.com/en/actions/how-tos/write-workflows/choose-what-workflows-do/run-job-variations

Review prompts (5 in total, most discussed first):

• comprehensive test coverage — llvm/llvm-project, Testing
• Use proper assertions — opencv/opencv, Testing
• Intentional Test Coverage — Tencent/ncnn, Testing
• systematic test coverage — ggml-org/llama.cpp, Testing
• Use specific test assertions — maplibre/maplibre-native, Testing

Documentation and comments

• Docs build — no tool detected in the sample. Catches: Broken cross-references, links and markup in documentation.
• Spelling: codespell (8% of repos). Docs: https://github.com/codespell-project/codespell

Review prompts (4 in total, most discussed first):

• Provide contextual code documentation — llvm/llvm-project, Documentation
• Documentation precision standards — ClickHouse/ClickHouse, Documentation
• Document implementation rationale — microsoft/terminal, Documentation
• Document function contracts — dotnet/runtime, Documentation

Source repositories

microsoft/terminal, pytorch/pytorch, ggml-org/llama.cpp, opencv/opencv, oven-sh/bun, ClickHouse/ClickHouse, llvm/llvm-project, duckdb/duckdb, hyprwm/Hyprland, Tencent/ncnn, facebook/yoga, dotnet/runtime, maplibre/maplibre-native

This site is open source. Improve this page.