home / skills / team-attention / plugins-for-claude-natives / review

This skill opens an interactive markdown review UI to inspect content, capture feedback, and export approved changes.

npx playbooks add skill team-attention/plugins-for-claude-natives --skill review

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.7 KB
---
name: review
description: Interactive markdown review with web UI. Use when user says "review this", "check this plan", "피드백", "검토해줘" or specifies a file path to review.
allowed-tools:
  - mcp__interactive_review__start_review
  - Read
---

# Interactive Review Skill

This skill opens an interactive web UI where users can review content with checkboxes and comments.

## How It Works

1. Determine the content source:
   - **If user specifies a file path**: Use the `Read` tool to get the file contents
   - **If user provides content directly**: Use that content as-is
   - **Otherwise**: Collect the most recent relevant content from the conversation
2. Call `mcp__interactive_review__start_review` with the content
3. A browser window opens automatically with the review UI
4. User reviews each item:
   - Check/uncheck to approve/reject
   - Add optional comments
5. User clicks Submit
6. Process the feedback and respond accordingly

## Content Sources (Priority Order)

1. **Explicit file path**: User says "review /path/to/file.md" or "이 파일 리뷰해줘: README.md"
   - Read the file using `Read` tool and use its contents
2. **Direct content**: User provides or references specific content to review
   - Use the provided content directly
3. **Conversation context**: Extract relevant content from recent conversation
   - Plans, documents, code, etc. that were recently discussed

## Usage

When the user wants to review content:

```
# If file path is specified, read it first:
Read({ "file_path": "/path/to/file.md" })

# Then start the review:
mcp__interactive_review__start_review({
  "content": "<content from file or conversation>",
  "title": "<descriptive title>"
})
```

## Processing Results

The tool returns a JSON with review items. Handle each item based on:

| checked | comment | Action |
|---------|---------|--------|
| true | empty | Approved - proceed as planned |
| true | has text | Approved with note - consider the feedback |
| false | has text | Rejected - modify according to comment |
| false | empty | Rejected - remove or reconsider this item |

## Example Flow

User: "Review this implementation plan"

1. Extract the plan content from recent output
2. Call start_review with the content
3. Wait for user feedback (tool blocks until submit)
4. Present summary of feedback
5. Ask if user wants you to proceed with approved items or revise rejected items

## Response Template

After receiving feedback:

```
## Review Summary

**Approved**: X items
**Needs revision**: Y items

### Items requiring changes:
- [Item]: [User's comment]

Would you like me to:
1. Proceed with approved items
2. Revise the rejected items based on feedback
3. Both - revise then proceed
```

Overview

This skill provides an interactive web-based markdown review UI that lets you approve, reject, and comment on individual items. It opens a browser window so you can check boxes, add notes, and submit structured feedback. Use it when you want a quick, collaborative pass over plans, docs, or code snippets.

How this skill works

The skill determines the content source from a file path, direct input, or recent conversation context, then launches the review UI by calling mcp__interactive_review__start_review. You interact with items via checkboxes and optional comments; when you submit, the tool returns a JSON summary of approvals and rejections. I parse that JSON and present a concise review summary and next-step options.

When to use it

  • You say: "review this", "check this plan", or provide a file path to review
  • You need line-item approvals or rejections with comments
  • You want an interactive, browser-based review session for markdown content
  • You prefer structured feedback (approved / needs revision) you can act on programmatically
  • You want to turn conversational content into a formal review quickly

Best practices

  • If reviewing a file, provide the explicit file path so the tool reads the correct source
  • Give a clear title or context to help reviewers focus on the right scope
  • Break large documents into sections before review to keep item lists manageable
  • Encourage reviewers to add short, actionable comments for any rejected item
  • After submission, decide whether to proceed with approved items or request revisions immediately

Example use cases

  • Review an implementation plan extracted from chat and get item-by-item approvals
  • Open a README.md or design doc for checklist-style review with comments
  • Quickly validate a release checklist or deployment plan with stakeholders
  • Collect structured feedback on a proposed API spec or feature list
  • Iteratively revise rejected items and then re-run the review

FAQ

What content sources does the skill support?

It supports explicit file paths (reads the file), direct pasted content, or relevant recent conversation content in that priority order.

How are results returned and acted on?

The review UI returns JSON with each item's checked state and comment; I summarize counts of approved and rejected items and list comments so you can choose to proceed, revise, or both.