Engineering

Review C# Code with AI

Correctness review with C#'s own traps: async deadlocks, undisposed IDisposables, double-enumerated LINQ, silenced nullability.

Open in Code Review Prompt Generator

Overview

C# correctness has language-shaped corners: a .Result on a task deadlocks under a synchronization context, an undisposed connection leaks until the pool starves, a LINQ query enumerates twice and doubles its cost, a ! suppresses the nullability warning that was right. This setup runs the twelve-check correctness review with the C# language pack covering exactly those four, under Strict style — every finding flagged, APPROVED or CHANGES REQUIRED — tuned for the hotfix that has to be right the first time.

How to use this resource

Run on the changed class, full file

Async and disposal problems live in the relationships between methods — snippet scope hides them.
Trust the async findings

Sync-over-async findings are CRITICAL in request paths even when the code "works" in development.
Audit the ! suppressions

Every nullability suppression the review flags was a place someone overruled the compiler — verify they were right.

Why This Works

C#'s worst bugs are language-mechanical — named checks find them where generic review can't
Strict style suits hotfixes: the cost of a missed finding exceeds the cost of reading nits
Correctness focus plus language pack reviews both the logic and the runtime behavior

Best for

.NET services where async correctness is production correctness
Hotfixes reviewed under time pressure
Teams migrating to nullable reference types honestly

Not for

Architecture-level review of the service design — switch focus to Architecture
A persistent C# reviewer persona — that's a System Prompt (SPG) job

Use cases

Reviewing service classes before a hotfix ships
Catching .Result deadlocks before they reach a request thread
Flagging undisposed resources before the pool starves

FAQ

What C#-specific bugs does this review prompt look for beyond generic code review?

Four language-mechanical traps, added as checklist items 13 to 16: .Result or .Wait() async-deadlock risk, undisposed IDisposable instances missing using statements, LINQ enumerated multiple times, and nullable annotations silenced with !. Code Review Prompt Generator writes these on top of the twelve generic checks; the prompt then runs in your own assistant, which surfaces candidate findings, not a guarantee it caught them all.

Will this C# review rewrite my code or just flag issues?

It reports findings only; the prompt states "Review only — report findings; do not rewrite the code." Each finding lands as one bullet with a severity tag and the exact line, function, or symbol cited, grouped CRITICAL first, ending in an APPROVED or CHANGES REQUIRED verdict. Applying the fixes and validating the merge stays with you.

Why is this tuned to flag every finding instead of only the important ones?

Its RULES say "Flag every finding, regardless of size" and "No praise padding." That fits the REVIEW OBJECTIVE, a hotfix that has to be right the first time, where reading a NIT costs less than missing a CRITICAL. The SEVERITY RULES add that severity reflects impact, not effort to fix, so you triage from the tagged list yourself.

Customize This Resource

Opens this setup in Code Review Prompt Generator. Generate to get the full review contract — then adjust the focus, scope, language, and style.

Open in Code Review Prompt Generator

Prompt Template

Copy it as-is, or use Open in Code Review Prompt Generator to load it pre-filled and customize it with your own context.

REVIEW OBJECTIVE
Review the order-processing service class for correctness before the hotfix ships.
Primary focus: correctness — find the ways this code produces wrong results or fails.
Review only — report findings; do not rewrite the code.

REVIEW SCOPE
You are reviewing a complete file — judge both the code and the file's structure: imports, ordering, and what this file owns.
Language: C#.

REVIEW CRITERIA
- Logic errors and inverted conditions
- Edge cases: empty, zero, negative, maximum, duplicate inputs
- Null/undefined/None handling before dereference
- Error paths: propagation, swallowed exceptions, partial failure states
- Concurrency: race conditions, unawaited async results, shared mutable state

SEVERITY RULES
- Tag every finding with exactly one severity: [CRITICAL], [MAJOR], [MINOR], or [NIT].
- CRITICAL: must be fixed before merge — bugs, vulnerabilities, data loss.
- MAJOR: should be fixed — real risk or real debt.
- MINOR: worth fixing — small risk or friction.
- NIT: style preference; fixing is optional.
- Severity reflects impact, not effort to fix.

REVIEW CHECKLIST
Work through every item; report only the items that fail:
1. Are inputs validated at the boundaries where they enter?
2. Are edge cases handled: empty, zero, negative, maximum-size inputs?
3. Any off-by-one errors in loops, slices, or range checks?
4. Is null/undefined handled before every dereference?
5. Do error paths return or propagate correctly — nothing swallowed silently?
6. Are async operations actually awaited and their failures handled?
7. Any race conditions on shared state or check-then-act sequences?
8. Are return values of fallible calls checked?
9. Are type coercions and implicit conversions intentional?
10. Are comparison boundaries correct (< vs <=, exclusive vs inclusive)?
11. Is there dead or unreachable code hiding an intent mismatch?
12. Does the code do what its name and comments claim it does?
C#-specific:
13. Any .Result or .Wait() on tasks — async deadlock risk?
14. Are IDisposable instances disposed (using statements)?
15. Any LINQ queries enumerated multiple times unintentionally?
16. Are nullable reference annotations honest, not silenced with !?

REQUIRED OUTPUT FORMAT
- One finding per bullet: [SEVERITY] location — what is wrong and why it matters.
- Group findings by severity, CRITICAL first.
- Cite the exact line, function, or symbol for every finding.
- Do not mention checklist items that pass — findings only.
- Flag every finding, regardless of size.
- No praise padding — findings only.

FINAL VERDICT
- End with a verdict: APPROVED or CHANGES REQUIRED — and list the findings that block approval.
- Base the verdict only on the findings listed above.

CODE TO REVIEW
[Paste the file here]

More resources from Code Review Prompt Generator

Resource

Code Review Prompt — the Review Contract

"Review this code" gets shallow comments. The review contract gets findings with severities, a checklist, and a verdict.

Prompt Engineering

Resource

Security Code Review Prompt

Twelve security checks — injection, auth, secrets, SSRF, privilege escalation — reviewed the way an attacker would read the code.

Engineering

Resource

API Review Checklist Prompt

Architecture review for the public surface: abstractions that earn their place, dependency direction, seams, and the patterns the codebase already has.

Engineering

Resources that pair well

Resource

Refactor Prompt — the Behavior Preservation Contract

"Refactor this code" invites silent behavior changes. The refactoring contract preserves business rules, outputs, and side effects — and flags uncertainty instead of deciding it.

Prompt Engineering

Resource

Playwright Test Prompt

getByRole over CSS chains, auto-wait over sleep, web-first assertions — Playwright tests written the way Playwright wants.

Engineering

Resource

Compare Two ChatGPT Prompts

A side-by-side way to decide between two ChatGPT prompt drafts — scored on clarity, specificity, output control, and risk instead of gut feeling.

Prompt Engineering

Related tools

Tool

Code Review Prompt Generator

Generate code review prompts for any scope — snippet, file, diff, or full pull request — with focused review rules.

Coding Workflows

Tip: Save time by exploring related resources and tools that integrate with this resource.