How the receiving-code-review Skill Processes Code Review Feedback

The receiving-code-review skill enforces a six-step verification workflow that prevents AI agents from blindly executing feedback, instead requiring them to read, understand, verify, evaluate, respond, and implement changes iteratively.

The receiving-code-review skill is part of the Superpowers plugin in the OpenAI plugins repository. It codifies a disciplined protocol for handling code review feedback that prioritizes technical correctness over immediate execution. By embedding this workflow directly into the skill definition, the OpenAI plugins codebase ensures that autonomous agents process reviewer comments with rigor and transparency.

The Six-Step Workflow for Processing Feedback

The skill mandates a specific sequence defined in plugins/superpowers/skills/receiving-code-review/SKILL.md. Each step prevents common failure modes like misinterpretation or breaking changes.

READ

The agent ingests the entire comment block without immediate reaction. This guarantees complete context absorption before any processing begins, ensuring the model sees the full scope of the request.

UNDERSTAND

The agent restates the requested change in its own words or asks focused clarifying questions. This surfaces hidden assumptions and prevents misinterpretations that could lead to incorrect implementations.

VERIFY

The agent checks the suggestion against the current codebase using tools like grep, build systems, or test runs. This ensures the proposed change is technically applicable to the specific repository state and current dependencies.

EVALUATE

The agent determines whether the change aligns with project architecture, compatibility requirements, and YAGNI principles. This blocks unnecessary feature additions that do not serve the current codebase needs.

RESPOND

The agent sends a concise technical acknowledgment or a reasoned push-back with evidence. This maintains transparent communication with human reviewers and prevents silent failures.

IMPLEMENT

The agent applies changes one item at a time, running the test suite after each modification. This guarantees regression-free updates even when processing multi-item feedback, with implementation ordered by impact (blocking → simple → complex).

Core Principles Embedded in the Skill

The Response Pattern sections and Forbidden Responses checklist in SKILL.md enforce specific behavioral constraints that distinguish this skill from generic code generation.

Technical rigor over social comfort. The model must verify before implementing, blocking performative agreement phrases like "You're absolutely right!" that appear in the forbidden language checklist.

YAGNI checks. Before adding features, the agent greps the repository to confirm whether the functionality is actually needed, as specified in the YAGNI check section of the skill definition.

Clear push-back. When suggestions conflict with existing behavior, the model explains the conflict with concrete code references rather than silent compliance or agreement.

Iterative implementation. Multi-item feedback is broken down and implemented in order of impact, with tests run after each discrete change to ensure stability.

Invoking the receiving-code-review Skill

Agents invoke this skill through the Codex runtime by specifying it in the tools configuration.

Basic Invocation

{
  "model": "gpt-4o",
  "messages": [
    {"role":"user","content":"Please review my PR #42 and fix the issues you find."}
  ],
  "tools": [
    {
      "type":"skill",
      "name":"receiving-code-review",
      "arguments": {}
    }
  ]
}

The agent responds with the READ → UNDERSTAND → VERIFY cycle, never jumping straight to "I'll fix it now."

Handling Ambiguous Feedback

When feedback contains uncertainty, the skill generates targeted clarification requests before proceeding to implementation:

Human reviewer: "Fix items 1-6 in the review, but I'm not sure about 4-5."
Agent: I understand items 1,2,3,6. I need clarification on items 4 and 5 before proceeding.

Only after explicit clarification does the agent continue with the VERIFY → IMPLEMENT steps.

Processing Concrete Requests

For unambiguous technical feedback, the skill produces detailed verification:

Human reviewer: "Remove the legacy networking code."
Agent: I understand you'd like the legacy networking module removed.
✅ I've searched the repo – src/network/legacy.py is imported in src/app/main.py.
❓ Does the project still need to support macOS 10.15? Removing it may break that target.

Key Source Files

The skill behavior is defined across three critical locations in the OpenAI plugins repository:

• plugins/superpowers/skills/receiving-code-review/SKILL.md – Contains the full skill description, response pattern definitions, and forbidden language checklist.

• plugins/superpowers/.codex-plugin/plugin.json – Registers the receiving-code-review skill within the Superpowers plugin bundle, making it discoverable to the Codex runtime.

• README.md – Provides the repository structure context showing where the Superpowers plugin lives in the overall collection.

Summary

• The receiving-code-review skill mandates a six-step workflow (READ, UNDERSTAND, VERIFY, EVALUATE, RESPOND, IMPLEMENT) to process feedback safely.
• It enforces YAGNI checks and technical verification before any code changes occur.
• The skill blocks performative agreement and requires concrete code references when pushing back on suggestions.
• Implementation occurs iteratively, one item at a time, with test validation after each change.
• Configuration resides in plugins/superpowers/skills/receiving-code-review/SKILL.md and is registered via plugin.json.

Frequently Asked Questions

What is the receiving-code-review skill in OpenAI Plugins?

The receiving-code-review skill is a workflow definition within the Superpowers plugin that governs how AI agents interpret and act on code review comments. It prevents automatic execution by requiring agents to verify suggestions against the actual codebase before implementing changes.

How does the receiving-code-review skill prevent breaking changes?

The skill requires agents to run the VERIFY step, which includes grepping the repository, checking imports, and running tests before modification. For example, if a reviewer suggests removing legacy code, the agent must first confirm that code is not imported by other critical components.

Can the receiving-code-review skill handle unclear or ambiguous feedback?

Yes. During the UNDERSTAND phase, the agent identifies ambiguous items and requests clarification before proceeding. It separates clearly understood feedback from items needing discussion, ensuring no assumptions drive implementation.

Where is the receiving-code-review skill defined in the codebase?

The primary definition resides in plugins/superpowers/skills/receiving-code-review/SKILL.md within the OpenAI plugins repository. The registration metadata is located in plugins/superpowers/.codex-plugin/plugin.json, which exposes the skill to the Codex runtime.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}