Engineering

Review C# Code with AI

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

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.

Workflow

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

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

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]

Related Resources

Explore more resources that work well with this one.