Most individuals’s immediate historical past seems to be like a junk drawer. A one-off request to elucidate an error message, a fast “clear this up,” a boilerplate generator used as soon as and forgotten. In June 2026, Google Cloud’s developer relations crew revealed one thing completely different: they requested ten of their very own engineers and leaders one particular query: what immediate do you personally refuse to work with out, and why? What got here again wasn’t a listing of intelligent phrasings. It was ten completely different engineers, independently arriving on the identical underlying transfer: utilizing AI as an adversarial second opinion moderately than an agreeable assistant.
That distinction is your complete topic of this text. Beneath are ten methods pulled from that piece, every one defined, attributed to the engineer who shared it, after which rebuilt as an unique instance immediate you may truly use — not copied verbatim, however reconstructed to point out the identical sample at work. Each instance applies to at least one operating mission: a small task-tracker REST API, so the methods construct on one another as an alternative of resetting to a brand new hypothetical each part.
# Constructing the Spec Earlier than Any Code Exists
Maja Bilić, a Senior Outbound Product Supervisor at Google Cloud, would not begin with code; she begins by making the mannequin argue together with her. Her method assigns the mannequin a particular, skeptical persona (a cynical principal architect and technical PM), explicitly forbids it from writing code, and has it checklist the important thing technical, UX, and architectural concerns for the thought earlier than asking focused questions on every one. As soon as that back-and-forth is completed, the mannequin turns the solutions into an precise necessities doc and implementation plan, with an instruction to not over-engineer or oversimplify both path.
The reasoning is price sitting with: a mannequin requested to assist “plan a characteristic” will typically simply agree with the primary framing you give it. A mannequin requested to critique an idea from a skeptical persona has to generate precise objections first, and people objections are often the place the true planning worth is.
Utilized to the duty tracker:
Act as a skeptical principal architect reviewing a proposed characteristic, not
writing code but. I need to add recurring duties to a task-tracker API,
duties that regenerate on a schedule (day by day, weekly, customized RRULE).
Don't write any code. Checklist the highest 5 technical, data-model, and UX
concerns this characteristic raises. For every one, ask me the particular
questions you want answered earlier than this could possibly be constructed responsibly.
As soon as I've answered all of them, draft a brief spec and implementation
plan. Do not over-engineer this for scale we do not have, and do not
oversimplify by ignoring timezone or edge-case dealing with.
# Making Testing Non-Negotiable
Andrew Brogdon, a Employees Developer Relations Engineer, makes use of a immediate that treats testing as one thing to audit moderately than generate. Slightly than asking for checks immediately, his sample has the mannequin first look at the codebase to search out which components of the UI or logic aren’t correctly coated, choose whether or not the prevailing code is even written in a testable method (dependencies injected, domains loosely coupled), and solely then construct and execute an precise testing plan — transferring one assured step at a time moderately than dashing straight to output.
The perception beneath this one is straightforward however straightforward to skip: asking immediately for checks will get you checks for no matter’s best to check, not what truly wants protection. Auditing testability first catches the hole between “examined” and “well-tested.“
Utilized to the duty tracker:
Companion with me on bettering check protection for this task-tracker API.
First, look at the codebase and establish which endpoints and enterprise
logic aren't correctly examined. Then assess whether or not the present code is
truly written in a testable method, are exterior calls injected or
hardcoded, is the scheduling logic remoted from the HTTP layer. Construct
a prioritized testing plan primarily based on what you discover, inform me what's
already coated, then implement the lacking checks. Do not skip forward to
writing checks till you are assured in your evaluation of what is
truly lacking.
# Operating the Two-Immediate Cleanup Move
Aja Hammerly, Director of Builder Relations, runs two separate, slender prompts earlier than handing code to overview — intentionally in a recent dialog with no improvement context connected. The primary asks the mannequin to run the prevailing checks, then particularly hunt for lacking edge circumstances and race situations. The second, run individually, seems to be for a special class completely: unused code, leftover debug feedback, feedback that now not match the code they describe, and unresolved TODOs — the sort of small, embarrassing residue that piles up whilst you’re targeted on the principle path by way of a characteristic.
Operating these as two distinct prompts moderately than one mixed request issues greater than it seems to be prefer it ought to. A single broad “overview this” immediate tends to mix all the things right into a generic go. Separating “what’s structurally lacking” from “what’s sloppy leftover” will get sharper solutions on each.
Utilized to the duty tracker:
[Fresh conversation, no prior context]
Run the check suite for this mission and establish any lacking checks.
Pay particular consideration to edge circumstances (empty recurrence guidelines, timezone
boundaries) and race situations (two requests updating the identical job
concurrently). Write the lacking checks.
[Same fresh conversation]
Look by way of this commit for unused code, leftover debug feedback,
feedback that now not match what the code truly does, unresolved
TODOs, or anything that should not ship. Checklist every one with a file
and line reference.
# Operating Area-Particular Compliance Checks
Wealthy Hyndman, Head of Antigravity Developer Relations, shared a extremely particular Android permissions audit: find each manifest file throughout construct variants, extract the declared permissions, cross-reference them towards precise utilization within the codebase to search out bloat, confirm runtime permission flows are applied accurately, and ensure any hardware-feature declarations line up. Crucially, the immediate ends with an specific instruction to not make any edits till the plan is accepted.
The sample generalizes effectively previous Android. Any compliance or configuration floor — atmosphere variable utilization, API scope grants, IAM position assignments — advantages from the identical form: find each declaration, cross-reference towards precise utilization, flag the hole, suggest fixes, watch for approval earlier than touching something.
Utilized to the duty tracker (its API authentication scopes, on this case):
Run a compliance verify on this API's authentication scopes. Find
each place a required OAuth scope is said (route decorators,
middleware config, API gateway guidelines) and construct a grasp checklist. Cross-
reference that checklist towards the place every scope is definitely checked in
the code, and flag any declared scope that is by no means enforced, or any
enforced verify that is not declared wherever. Output a markdown report
with file paths and steered diffs. Don't make any edits till I
approve the plan.
# Grading Your Personal Code Like a Harsh Reviewer
Shir Meir Lador, Head of AI Developer Relations, names an actual downside immediately: ask a mannequin for a code overview, and it often defaults to well mannered — a praise on naming, a suggestion for a docstring, a inexperienced gentle. Her repair is to assign a particular, demanding persona (a strict principal engineer with zero tolerance for happy-path code), then power an precise letter grade (A by way of F) on manufacturing readiness, explicitly instructing the mannequin to not hand out an A except the code is genuinely strong throughout effectivity, resilience, and structure. The immediate closes by requiring precise fixes, not simply commentary.
That is price utilizing particularly due to how effectively it exposes the hole between “this code seems to be tremendous” and “this code is okay.” A grading rubric with an actual failing situation forces the mannequin to really search for what would break, moderately than defaulting to encouragement.
Utilized to the duty tracker:
Act as a strict principal engineer doing a pre-production overview. Zero
tolerance for fragile, happy-path-only code. Grade my uncommitted
adjustments A by way of F for manufacturing readiness, do not give an A except
it is genuinely strong. Particularly verify for: redundant database
queries or lacking caching, silent failure factors and lacking error
boundaries across the scheduler, and tight coupling between the
recurrence logic and the HTTP layer. For each concern, clarify precisely
the way it fails in manufacturing, then give me the git diff to repair it and
earn that grade.
# Making the Mannequin Defend Its Personal Plan
James O’Reilly, the publish’s writer and a Employees Developer Relations Engineer, makes use of one of many shortest prompts on the checklist — and it is arguably a very powerful: after getting an implementation plan, ask the mannequin to explicitly lay out the trade-offs of its personal suggestion throughout efficiency, value, safety, and maintainability. The purpose is not extra code; it is forcing the mannequin to stress-test its personal reasoning moderately than letting its first suggestion stand unchallenged.
This immediately counters a particular failure mode of working with AI on technical choices: it is simple for a mannequin’s assured, well-formatted plan to really feel like a settled resolution moderately than one choice amongst a number of. Making it checklist what it is buying and selling away retains a human within the precise resolution seat.
Utilized to the duty tracker:
Clarify the trade-offs of the recurring-tasks implementation plan you
simply proposed. Be particular about what we're giving up on efficiency,
value, safety, and long-term maintainability in comparison with a minimum of one
various method, so I could make an knowledgeable name as an alternative of simply
taking your first plan as last.
# Turning Exterior Analysis Right into a Evaluation Guidelines
Emma Twersky, Head of Flutter & Dart Developer Relations, factors the mannequin outward earlier than it seems to be inward: analysis real-world safety pitfalls, architectural errors, and delicate logic errors particular to AI-generated code in a given tech stack — drawing on developer boards, GitHub points, and technical blogs — then convert these findings right into a focused guide overview guidelines for the highest-risk components of the codebase.
The reasoning behind this one carries actual weight. A well known 2022 research on GitHub Copilot — analyzing 1,689 generated packages throughout 89 security-relevant eventualities, discovered that roughly 40% contained an actual vulnerability — a discovering that later, bigger research have continued to bolster moderately than overturn. AI-written code would not look incorrect. It compiles, it passes an off-the-cuff look, and that is precisely what makes an exterior, evidence-based guidelines extra helpful than a generic “overview this for bugs” request.
Analysis present safety pitfalls and delicate logic errors generally
present in AI-generated FastAPI code, specializing in developer boards,
GitHub concern trackers, and up to date technical write-ups. Based mostly on what
you discover, construct a guide overview guidelines particularly for auditing
this mission's highest-risk areas: the scheduling/cron logic, webhook
signature verification, and the way job possession is checked on replace
requests.
# Iterating in Phases, Not One Mega-Immediate
Fred Sauer, Head of Frameworks & Languages Developer Relations, would not describe a single immediate a lot as a staged workflow. Early on, in a discovery section, he intentionally stays much less particular — arguing that being too prescriptive early creates blind spots the mannequin will not assume to query. That is adopted by a proof-of-concept go simply to substantiate the thought is buildable in any respect, then refinement towards one thing he’d be glad to have written himself, and solely on the finish — in a recent dialog for a genuinely new perspective — a last code overview, iterated till the findings get boring, that means there’s nothing important left to catch.
The lesson generalizes previous his particular steps: matching immediate specificity to the precise stage of the work — free early, exact late — tends to catch greater than both being obscure the entire method by way of or over-specifying from the very first immediate.
Utilized to the duty tracker, the final-stage immediate seems to be like this:
[Fresh conversation]
Code overview the uncommitted adjustments. Establish any unhandled nook
circumstances. Assess efficiency. Summarize findings.
And after getting again a listing of findings:
Repair findings 2, 4, and 5. Go away the others, I've determined they don't seem to be
definitely worth the added complexity proper now.
# Automating the Evaluation With a Actual Script
Remigiusz Samborski, a Lead Developer Relations Engineer, takes this sample furthest: as an alternative of remembering to ask for a overview, his crew wires an automatic overview agent immediately into GitHub Actions, so each single pull request will get a structured, adversarial overview with zero likelihood of somebody forgetting to ask. His precise manufacturing immediate runs by way of Gemini CLI as a GitHub Motion, and the total model is public on GitHub if you wish to see the true factor.
Here is a working model of that very same thought constructed independently and examined finish to finish — a Python script that pulls the precise git diff and sends it by way of the identical grading-rubric sample from part 5, meant to run in CI on each PR:
"""
auto_review.py
Runs a structured, adversarial code overview towards the present git diff.
Meant to run in CI on each pull request, so overview occurs
routinely as an alternative of relying on somebody remembering to ask.
"""
import os
import subprocess
import sys
import anthropic
REVIEW_PROMPT = """You're a strict, principal-level code reviewer with zero
tolerance for fragile, happy-path-only code. Evaluation the diff beneath and grade
it A by way of F for manufacturing readiness. Don't award an A except the code is
genuinely strong. For every concern discovered, cowl:
1. Effectivity: redundant calls, uncached lookups, wasteful queries.
2. Resilience: silent failure factors, lacking error dealing with, no fallback
conduct for exterior calls.
3. Structure: tight coupling, unclear separation of issues.
For each concern, clarify concretely the way it might fail in manufacturing, then
give the precise repair. Output as a markdown report with a letter grade on the high.
DIFF:
{diff}
"""
def get_diff() -> str:
"""Pulls the precise staged diff from git, falling again to unstaged."""
end result = subprocess.run(
["git", "diff", "--staged"], capture_output=True, textual content=True, verify=True
)
diff = end result.stdout
if not diff.strip():
end result = subprocess.run(["git", "diff"], capture_output=True, textual content=True, verify=True)
diff = end result.stdout
return diff
def review_diff(diff: str) -> str:
"""Sends the diff to the mannequin and returns the markdown overview."""
shopper = anthropic.Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
response = shopper.messages.create(
mannequin="claude-sonnet-4-6",
max_tokens=2000,
messages=[{"role": "user", "content": REVIEW_PROMPT.format(diff=diff)}],
)
return "".be part of(block.textual content for block in response.content material if block.sort == "textual content")
def predominant():
diff = get_diff()
if not diff.strip():
print("No adjustments to overview.")
sys.exit(0)
report = review_diff(diff)
with open("review_report.md", "w") as f:
f.write(report)
print(report)
if __name__ == "__main__":
predominant()
What this does:
get_diffshells out to git and grabs no matter’s staged, falling again to unstaged adjustments if nothing’s staged but, so the script works whether or not it is run domestically earlier than a commit or in CI towards a PR department.review_diffdrops that uncooked diff into the identical adversarial grading immediate from part 5 and sends it to the mannequin, then pulls the plain textual content again out of the response.predominantties it collectively, writing the overview to a file so a CI step can publish it as a PR remark, and exiting cleanly with no API name in any respect if there’s nothing to overview.
Stipulations and how you can run it:
- Python 3.9+
pip set up anthropic- An
ANTHROPIC_API_KEYset in your atmosphere. - Domestically, run
python auto_review.pyafter staging some adjustments withgit add. In CI, the identical script slots right into a GitHub Actions step that runs on eachpull_requestoccasion, with the output posted as a remark by way of the GitHub API — the identical finish purpose as Samborski’s setup, simply constructed from scratch right here moderately than reusing his precise configuration.
# Pondering in Graphs, Not Checklists
Karl Weinmeister, Director of Developer Relations, closes the unique checklist with the least standard method: as an alternative of asking for a generic checklist of check concepts — which tends to provide the identical boilerplate guidelines whatever the precise mission — he has the mannequin characterize the applying’s workflow as a directed acyclic graph (nodes and edges) and cause structurally about the place failures might propagate. He particularly asks it to weigh “seams” — a time period borrowed immediately from Michael Feathers’ work on legacy code — that means the boundaries between parts which might be often under-tested exactly as a result of no single part owns them. The output is a prioritized markdown desk moderately than a flat checklist.
Utilized to the duty tracker:
Mannequin this software's workflow as a directed acyclic graph: request
is available in, auth middleware, task-ownership verify, recurrence-expansion
logic, database write, webhook dispatch. Establish the highest-impact
checks for particular person parts, and individually for the seams between
them, the boundaries the place two parts hand off and neither one is
clearly answerable for validating what crosses that boundary. Current
your findings as a prioritized markdown desk: seam, danger, and
steered check.
# Wrapping Up
Line all ten of those up subsequent to one another, and the sample connecting them stops being delicate. None of those prompts exists to save lots of typing, and none of them is about getting extra code out of the mannequin quicker. Each single one exists to de-risk a human assumption — the idea that the completely happy path is sufficient, {that a} first plan is the best plan, {that a} look at a diff counts as a overview. When you solely undertake one factor from this text, make it part 5’s grading rubric, since it is the quickest solution to really feel the precise distinction between a mannequin that is being well mannered and one which’s genuinely working towards your blind spots, and as soon as that distinction is seen, the remainder of these methods begin making much more sense as variations on the identical thought.
Shittu Olumide is a software program engineer and technical author captivated with leveraging cutting-edge applied sciences to craft compelling narratives, with a eager eye for element and a knack for simplifying advanced ideas. You may also discover Shittu on Twitter.
