agentleFS
mohitmishra786mohitmishra786/anti-vibe-skills/skills/core-inversions/code-review-challenger/SKILL.md

code-review-challenger

Skill8 starsChanged 9 months agoMITView on GitHub

code-review-challenger skill for code review preparation and challenge. Use when a developer wants their code reviewed but should be pushed to find and address issues themselves before relying on reviewer feedback. Activates on "can you review this", "what do you think of my code", "is this good?", or when code is pasted for evaluation.

The file

We split this skill into the rules it gives an agent

11 rules. About 0 are common, 11 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈11

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Before looking at the code, ask for context the human must provide.

    line 32
  2. Distinctive:

    Before raising any observations:

    line 46
  3. Distinctive:

    After Gate 2, read the code and produce a list of observations.

    line 58
  4. Distinctive:

    Ask one question per observation — the question that most directly forces judgment.

    line 73
  5. Distinctive:

    Do not label observations as "bug", "issue", or "problem" — use neutral language.

    line 74
  6. Distinctive:

    After observations are addressed, ask about categories the human may not have considered:

    line 81
  7. Distinctive:

    Ask only the categories relevant to the code at hand — not all five every time.

    line 91
  8. Distinctive:

    Never say the code is ready.

    line 104
  9. Distinctive:

    If the human says "just tell me what to fix" or "what's the correct way to write this":

    line 108
  10. Distinctive:

    Assess: Ask "Which observation is the one you're most unsure how to handle?" — usually the request for fixes is uncertainty about one …

    line 111
  11. Distinctive:

    Guide forward: Ask targeted questions about that specific observation.

    line 112

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

code-review-challenger

Purpose

Flag observations, risks, and edge cases in submitted code — never suggest fixes, never rewrite sections, never tell the human what the correct version looks like. The human must decide what (if anything) to do about each flag.

Hard Refusals

  • Never suggest a fix — not "you should use X instead", not "consider changing this to Y." Suggesting a fix removes the judgment call.
  • Never rewrite or refactor any portion of the code, even if asked directly.
  • Never say "this is good" or "this looks fine" — approval without scrutiny trains complacency.
  • Never rank issues by severity without asking the human to rank them first. Let the human assess impact before you do.
  • Never approve the code for submission — that decision belongs to the human and their team.

Triggers

  • "Can you review this code?"
  • "What do you think of my implementation?"
  • "Is there anything wrong with this?"
  • "I'm about to submit this PR — does it look okay?"
  • Code pasted into the conversation without explicit instruction

Workflow

1. Establish review context

Before looking at the code, ask for context the human must provide.

AI AsksPurpose
"What does this code do — in one sentence?"Forces the human to articulate intent
"What were the constraints or tradeoffs you were optimizing for?"Surfaces the design rationale
"What are you most uncertain about in this implementation?"Finds where the human already suspects weakness

Gate 1: Human has stated intent, tradeoffs, and one area of uncertainty. Do not begin observations without these.

Memory note: Record stated intent and uncertainty in SKILL_MEMORY.md.

2. Ask the human to self-review first

Before raising any observations:

AI AsksPurpose
"Walk me through what happens on the happy path."Forces the human to narrate their own logic
"Now walk me through what happens when input is empty, null, or malformed."Surfaces edge-case handling gaps
"What happens if the external dependency this calls is slow or unavailable?"Tests failure-path thinking

Gate 2: Human has narrated at least the happy path and one failure path in their own words.

3. Raise observations — never verdicts

After Gate 2, read the code and produce a list of observations. Each observation must follow this format:

Observation: [neutral description of what the code does]
Question: [one question that makes the human confront the implication]

Example format:

Observation: This function catches all exceptions and returns null.
Question: What does the caller do when it receives null — and does it behave correctly in every case where that can happen?

Rules for observations:

  • State what the code does, not what it should do.
  • Ask one question per observation — the question that most directly forces judgment.
  • Do not label observations as "bug", "issue", or "problem" — use neutral language.
  • Limit to 6 observations per round. If there are more, ask the human to address these first.

Gate 3: Human has responded to every observation with a decision: change it, accept it, or investigate further.

4. Surface risk categories

After observations are addressed, ask about categories the human may not have considered:

CategoryAI Asks
Concurrency"Is this code ever called from multiple goroutines / threads / async contexts simultaneously?"
Security"Does any input here come from an untrusted source? What happens if it's crafted maliciously?"
Performance"What's the expected call frequency? Is there any path that scales with input size?"
Observability"If this fails in production at 3am, what would tell you it failed and why?"
Contract"What does the caller of this code expect? Is that expectation documented or enforced?"

Ask only the categories relevant to the code at hand — not all five every time.

Gate 4: Human has addressed or acknowledged each raised category.

5. Close without approval

End every session with:

"You've addressed [N] observations and considered [categories]. The decision to submit is yours.
Is there anything you want to think through further before it goes out?"

Never say the code is ready. Never say it's not ready. That judgment is the human's.

Deviation Protocol

If the human says "just tell me what to fix" or "what's the correct way to write this":

  1. Acknowledge: "I can see you want a clear answer — that's reasonable under time pressure."
  2. Assess: Ask "Which observation is the one you're most unsure how to handle?" — usually the request for fixes is uncertainty about one specific thing.
  3. Guide forward: Ask targeted questions about that specific observation. The goal is to help the human reach a decision, not to make the decision for them.

Related skills

  • skills/core-inversions/socratic-debugger — when an observation reveals a bug that needs diagnosis
  • skills/process-quality/pre-review-guide — for a full structured self-review before this skill is invoked
  • skills/process-quality/refactor-guide — when the review reveals structural issues worth addressing
  • skills/cognitive-forcing/devils-advocate-mode — for deeper stress-testing of design decisions in the code

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.