receiving-orders

Evaluate code-review feedback against the codebase and implement changes incrementally.

71|9|Updated Apr 13, 2026
One-click install
npx skills add https://github.com/kucherenko/gangsta --skill receiving-orders
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: receiving-orders
Source: https://github.com/kucherenko/gangsta/tree/main/skills/receiving-orders
Command: npx skills add https://github.com/kucherenko/gangsta --skill receiving-orders

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Code reviews can devolve into performative agreement; this skill ensures feedback is evaluated technically, grounded in the codebase, and acted upon with disciplined judgment.

Core Features & Use Cases

  • Technical verification: Restate requirements, verify against the codebase, and determine whether changes are warranted.
  • Structured response: Follow a disciplined six-step protocol to avoid blind agreement and improve engineering quality.
  • Incremental implementation: Tackle items one at a time and validate each change with tests.

Quick Start

Ask for clarification if uncertain, then verify requirements against the codebase, push back with technical reasoning when needed, and implement items one at a time with validation.

Frequently Asked Questions about receiving-orders

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I process code-review feedback without blindly agreeing to every suggestion?

Process code-review feedback by restating requirements, verifying against the codebase, and pushing back with engineering reasoning when changes are unwarranted. This prevents performative agreement and ensures feedback is evaluated with technical rigor before implementation.

What is the best way to push back on a code review comment technically?

Push back on code review comments by applying technical scrutiny to verify the requirement against your codebase. Ask clarifying questions if uncertain, then use engineering reasoning to justify your stance rather than accepting feedback passively.

How do I implement code review changes incrementally?

Implement code review changes incrementally by tackling one item at a time and validating each modification with tests. This disciplined approach ensures contract-aligned decisions and prevents unsafe actions during the feedback processing cycle.

Can I use a structured protocol for verifying code review requirements?

You can verify code review requirements using a structured six-step protocol with Omerta-style guardrails. This enforces technical verification, prevents unsafe actions, and ensures contract-aligned decisions when processing feedback.

When should I ask clarifying questions during a code review cycle?

Ask clarifying questions during a code review cycle whenever you are uncertain about feedback. Verify these requirements against the codebase first, then determine if changes are warranted before proceeding with incremental implementation.