AgentStack
Browse Sign in
Browse Why AgentStack Sell Docs
Sign in
SKILL verified Apache-2.0 Self-run

Structured Code Review

skill-rohitg00-skillkit-structured-review · by rohitg00

Performs a structured five-stage code review covering requirements compliance, correctness, code quality, testing, and security/performance. Each stage uses targeted checklists and categorized feedback (Blocker/Major/Minor/Nit) with actionable suggestions and rationale. Use when the user asks for code review, PR feedback, pull request review, or wants their code checked for bugs, style issues, or…

No reviews yet
0 installs
33 views
0.0% view→install

Install

$ agentstack add skill-rohitg00-skillkit-structured-review

✓ scanned · ✓ verified, works with Claude Code, Cursor, and more.

Security review

✓ Passed

No issues found. Passed automated security review. · v0.1.0 How review works →

  • Prompt-injection patterns
  • Secret / credential exfiltration
  • Dangerous shell & filesystem operations
  • Untrusted network calls
  • Known-malicious package signatures

What it can access

  • Network access No
  • Filesystem access No
  • Shell / process execution No
  • Environment & secrets No
  • Dynamic code execution No

From automated source analysis of v0.1.0. “Used” means the capability is present in the source — more access means more to trust, not that it’s unsafe.

View the full security report →

Verified badge

Passed review? Show it. Paste this badge into your README, it links to the public security report.

AgentStack Verified badge Links to your public security report.
[![AgentStack Verified](https://agentstack.voostack.com/badges/verified.svg)](https://agentstack.voostack.com/security/report/skill-rohitg00-skillkit-structured-review)

Reliability & compatibility

Security review passed
0 installs to date
no reviews yet
3mo ago

Declared compatibility

Claude CodeClaude Desktop

Compatibility is declared by the source manifest. End-to-end runtime verification is coming, see below.

Preview Execution monitoring

We're building live execution health for every listing: tool-call success rate, median latency, uptime, and last-checked timestamps, measured, not self-reported. It isn't live yet, so we don't show numbers we can't stand behind.

How agent discovery & health will work →
Are you the author of Structured Code Review? Claim this listing to set pricing, connect Stripe payouts, and keep 70% of every sale.
Sign up to claim

About

Structured Code Review

You are performing a structured, multi-stage code review. This methodology ensures thorough review while providing actionable, constructive feedback.

Core Principle

Review in stages. Each stage has a specific focus. Don't mix concerns.

A structured review catches more issues and provides better feedback than an unstructured scan.

Review Stages

Stage 1: Requirements Compliance

First, verify the code meets its requirements.

Checklist:

  • [ ] Implements stated requirements
  • [ ] Handles specified edge cases
  • [ ] No scope creep (unexpected additions)
  • [ ] No missing functionality

Feedback at this stage:

  • "This doesn't appear to handle the case when X is empty"
  • "The requirement specified Y, but this implements Z"
  • "This adds feature F which wasn't requested - is that intentional?"

Stage 2: Correctness

Next, verify the code works correctly.

Checklist:

  • [ ] Logic is sound
  • [ ] No obvious bugs
  • [ ] Error paths are handled
  • [ ] No unfinished code (TODOs without tickets)

Feedback at this stage:

  • "This will throw if user is null"
  • "The loop exits early before processing all items"
  • "What happens when the API call fails?"

Stage 3: Code Quality

Then, evaluate code quality and maintainability.

Checklist:

  • [ ] Clear naming
  • [ ] Reasonable function/method length
  • [ ] No unnecessary complexity
  • [ ] Follows project conventions
  • [ ] Appropriate abstractions

Feedback at this stage:

  • "Could you rename data to userProfile for clarity?"
  • "This function is doing three things - consider splitting"
  • "We use camelCase for variables in this project"

Stage 4: Testing

Evaluate test coverage and quality.

Checklist:

  • [ ] New code has tests
  • [ ] Tests cover main paths and edge cases
  • [ ] Tests are readable and maintainable
  • [ ] Tests don't test implementation details

Feedback at this stage:

  • "Please add a test for the error case"
  • "This test will break if we change the implementation"
  • "Consider using a parameterized test for these cases"

Stage 5: Security & Performance

Finally, check for security and performance concerns.

Checklist:

  • [ ] No SQL injection, XSS, etc.
  • [ ] Secrets not exposed
  • [ ] No obvious N+1 queries
  • [ ] No unnecessary computation
  • [ ] Sensitive data handled correctly

Feedback at this stage:

  • "This input should be sanitized before use"
  • "Consider adding an index for this query"
  • "This API key should come from environment variables"

Writing Good Feedback

Feedback Levels

| Level | When to Use | Example | |-------|-------------|---------| | Blocker | Must fix before merge | "Security: This allows SQL injection" | | Major | Should fix, but not critical | "This will fail for empty arrays" | | Minor | Suggestion, nice to have | "Consider renaming for clarity" | | Nit | Trivial, stylistic | "Extra blank line here" |

Constructive Feedback Template

[Level] [Category]: [Issue]

**What:** [Describe the specific issue]
**Why:** [Explain why it matters]
**Suggestion:** [Offer a specific improvement]

Example:

[Major] Correctness: Null reference possible

**What:** `user.email` is accessed without checking if user exists
**Why:** This will throw TypeError when user is not found
**Suggestion:** Add `if (!user) return null;` before accessing properties

Review Checklist Summary

## Review: [PR Title]

### Stage 1: Requirements
- [ ] Implements requirements
- [ ] Handles edge cases
- [ ] Appropriate scope

### Stage 2: Correctness
- [ ] Logic is sound
- [ ] No bugs
- [ ] Errors handled

### Stage 3: Quality
- [ ] Readable
- [ ] Follows conventions
- [ ] Maintainable

### Stage 4: Testing
- [ ] Has tests
- [ ] Tests are good

### Stage 5: Security/Performance
- [ ] No vulnerabilities
- [ ] No performance issues

### Verdict: [ ] Approve [ ] Request Changes [ ] Comment

Integration with Other Skills

  • planning/verification-gates: Review is a key gate
  • testing/test-patterns: Evaluate test quality
  • testing/anti-patterns: Spot testing issues

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

Install and usage instructions live in the source repository linked above.

Reviews

No reviews yet, be the first.

Versions

  • v0.1.0 Imported from the upstream source.