Engineering

Senior Code Reviewer Role Prompt

A principal-level code reviewer role prompt — blast-radius thinking, severity-ranked findings, and style left to the linter where it belongs.

Open in Role Prompt Generator

Overview

'Review my code' without a role gets you a line-by-line commentary that treats a typo and an injection risk as equals. This role prompt builds the reviewer experienced teams actually have: one who reviews the change's blast radius rather than just its lines, separates must-fix from nit explicitly, and leaves style to the linter so attention goes to correctness, security, and design. The principal level adds reversibility awareness — extra caution exactly where mistakes are expensive.

How to use this resource

Open in the generator

Principal level, Technology industry, Risk-Aware style, Correctness + Security focus — pre-set.
Generate, paste, then add the diff

Role prompt first, then the code or diff with one line of context about what it's supposed to do.
Demand the severity split

The must-fix/should-fix/nit contract is the difference between a review and a reaction.

Why This Works

Blast-radius framing catches the integration bugs that line-by-line review misses
Severity discipline makes the feedback actionable in priority order
Questions-over-verdicts keeps the review collaborative — the reviewer can be wrong too

Best for

Solo developers without access to senior review
Teams that want a consistent first-pass review bar
Security-sensitive changes that deserve paranoid eyes

Not for

An automated PR-review pipeline with output contracts — the System Prompt Generator's code review assistant covers that
Style and formatting enforcement — configure a linter instead

Use cases

Getting severity-ranked review feedback instead of a flat comment list
Pre-reviewing your own PR before human reviewers see it
Teaching junior developers what experienced reviewers look for

FAQ

What output format does the senior code reviewer role prompt produce?

It outputs findings tagged by severity — must-fix, should-fix, or nit — each with a file reference, so a typo and an injection risk never sit at the same priority. When it rejects an approach it proposes the alternative rather than just objecting. You paste your diff and run it in ChatGPT, Claude, or Gemini — the severity contract is the format, not an automated pipeline.

Why does this code review prompt skip style and formatting comments?

By design it treats style as the linter's job and points the reviewer's attention at logic, security, and design instead. That's why it won't fill the review with spacing and naming nits — those are cheaper to enforce automatically, so spending a human-style review on them wastes it. Configure a linter for formatting and let this prompt focus on correctness and security, its two weighted focus areas.

When should I not use the code reviewer role prompt for reviews?

Don't reach for it when you need an automated PR-review pipeline with a fixed output contract wired into CI — this is a conversational role prompt you drive by hand, one diff at a time. It also won't replace a linter for style enforcement. Use it when you want a principal-level pass on correctness and security before you open the PR, not an unattended gate.

Does this role prompt actually review my code, or do I still run it myself?

You run it yourself — NewPrompt gives you the role prompt, and you paste it plus your diff into your own AI tool to get the review. The findings are a prioritized, senior-level read on correctness and security, not a guarantee that every bug or vulnerability is caught. Treat must-fix items as a strong signal to verify, and keep a human reviewer accountable for merging.

Customize This Resource

Opens these inputs in Role Prompt Generator. Generate to get the full role prompt — then adjust level, style, and focus areas.

Open in Role Prompt Generator

Prompt Template

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

Role: Principal Senior Code Reviewer — Technology

You are a principal senior code reviewer with 10+ years of experience operating at organizational scope in reviewing production code — correctness, security, maintainability, and the judgment calls between them. You work primarily in Technology contexts.

Perspective — how you see problems:
- The diff is guilty until proven innocent — but most comments should still be questions
- Review the change's blast radius, not just its lines
- Style belongs to the linter; reviewer attention belongs to logic, security, and design

Responsibilities — what you own in this conversation:
- Catch correctness and security issues before they ship
- Distinguish must-fix from nice-to-have explicitly in every review
- Explain the why behind each finding so the author levels up

Decision criteria — weigh every recommendation against:
- Correctness — edge cases, error paths, concurrency, and data integrity
- Security — input validation, authentication surfaces, and injection risks
- Maintainability — will the next person understand and safely change this

Focus areas for this session: Correctness, Security.
Weight your attention toward these — go deeper here than anywhere else.

Working style:
- Name the biggest risk and its mitigation in every recommendation.
- Answer at systems level: how the decision interacts with the team, process, and strategy around it.
- Distinguish reversible from irreversible decisions and calibrate caution accordingly.
- Consider scalability and technical-debt implications alongside the immediate ask.

Instructions:
- Stay in this role for the entire conversation.
- If a request falls outside this role's expertise, say so rather than improvising an answer.
- Ground advice in the perspective and decision criteria above — they are your reasoning framework, not decoration.

Output expectations:
- Output findings with severity (must-fix / should-fix / nit) and file references.
- When rejecting an approach, propose the alternative — a review without a path forward is a complaint.

More resources from Role Prompt Generator

Resource

Product Manager Role Prompt

A complete 'act as a product manager' role prompt — the perspective, responsibilities, and decision criteria a real PM brings, not just the job title.

Product

Resource

Startup Advisor Role Prompt

An expert startup advisor role prompt — stage-aware, capital-efficiency-minded, and built to name the riskiest assumption in any plan instead of cheering it on.

Operations

Resource

Authentication Strategy Prompt

Choose how users prove who they are — sessions vs tokens, passwords vs passwordless, SSO and MFA — decided on your real constraints, not the default tutorial.

Engineering

Resources that pair well

Resource

Bug Triage Assistant

Convert scattered bug notes, Slack messages, or user complaints into structured engineering tasks with reproduction steps, severity, and root cause hypothesis.

Engineering

Resource

Fix a Vague Prompt

'Make it good', 'be detailed', 'keep it interesting' — vague prompts get vague output. The fix is mechanical: replace every fuzzy word with a checkable instruction.

Prompt Engineering

Resource

Agent Task Template

A reusable AI agent task template with variables for objective, context, available tools, constraints, success criteria, failure handling, and output format.

AI Agents

Related tools

Tool

Role Prompt Generator

Generate expert role prompts — perspective, responsibilities, and decision criteria, not just "act as".

Prompt Builders

Guides for this resource

Guide

Write a Role Prompt That Doesn't Overreach

"Act as a lawyer" makes AI answer with authority it doesn't have — a verdict or a diagnosis from partial context. Here's how to write a role prompt that gives an expert lens without the overreach: scope, allowed and forbidden actions, and decision ownership that stays yours.

Prompt Engineering

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