home / skills / supercent-io / skills-template / planview

planview skill

/.agent-skills/planview

This skill helps you review AI plans and diffs with inline annotations, approve iterations, and feedback loops before implementation.

npx playbooks add skill supercent-io/skills-template --skill planview

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

Files (2)
SKILL.md
4.0 KB
---
name: plannotator
keyword: planno
description: Interactive plan and diff review for AI coding agents. Visual browser UI for annotating agent plans — approve or request changes with structured feedback. Supports code review, image annotation, and auto-save to Obsidian/Bear Notes.
allowed-tools: [Read, Bash, Write]
tags: [planno, plannotator, plan-review, diff-review, code-review, claude-code, opencode, annotation, visual-review]
platforms: [Claude, OpenCode, Codex, Gemini]
version: 0.8.2
source: backnotprop/plannotator
---

# plannotator — Interactive Plan & Diff Review (planno)

> Keyword: `planno` | Source: https://github.com/backnotprop/plannotator
>
> Annotate and review AI coding agent plans visually, share with your team, send feedback with one click.
> Works with **Claude Code** and **OpenCode**.

## When to use this skill

- You want to review an AI agent's implementation plan BEFORE it starts coding
- You want to annotate a git diff after the agent makes changes
- You need a feedback loop: visually mark up what to change, then send structured feedback back
- You want to share plan reviews with teammates via a link
- You want to auto-save approved plans to Obsidian or Bear Notes

---

## Step 1: Install Plannotator CLI

```bash
# macOS / Linux / WSL
curl -fsSL https://plannotator.ai/install.sh | bash

# Windows PowerShell
irm https://plannotator.ai/install.ps1 | iex
```

---

## Step 2: Connect to Your Agent CLI

### Claude Code

```bash
/plugin marketplace add backnotprop/plannotator
/plugin install plannotator@plannotator
# IMPORTANT: Restart Claude Code after plugin install
```

### OpenCode

Add to `opencode.json`:

```json
{
  "plugin": ["@plannotator/opencode@latest"]
}
```

Then run the install script and restart OpenCode.

---

## Step 3: Plan Review (Before Coding)

When your agent finishes planning (Claude Code: `Shift+Tab×2` to enter plan mode), Plannotator automatically opens a browser UI:

1. **View** the agent's plan in the visual UI
2. **Annotate** with clear intent:
   - `delete` — remove risky or unnecessary step
   - `insert` — add missing step
   - `replace` — revise incorrect approach
   - `comment` — clarify constraints or acceptance criteria
3. **Submit** one outcome:
   - **Approve** → agent proceeds with implementation
   - **Request changes** → your annotations are sent back as structured feedback for replanning

---

## Step 4: Code Review (After Coding)

Run `/plannotator-review` to review git diffs with inline annotations:

```bash
/plannotator-review
```

- Select line numbers in the diff to annotate specific changes
- Switch between unified/split diff views
- Add image attachments with annotations (pen, arrow, circle tools)
- Send feedback directly to the agent

---

## Step 5: Auto-save & Sharing (Optional)

- **Obsidian** and **Bear Notes**: Approved plans are automatically saved
- **Share link**: Share a plan review session with teammates for collaboration

---

## Remote/Devcontainer Configuration

```bash
export PLANNOTATOR_REMOTE=1   # No auto browser open
export PLANNOTATOR_PORT=9999  # Fixed port
```

| Variable | Description |
|----------|-------------|
| `PLANNOTATOR_REMOTE` | Remote mode (no auto browser open) |
| `PLANNOTATOR_PORT` | Fixed local/forwarded port |
| `PLANNOTATOR_BROWSER` | Custom browser path/app |
| `PLANNOTATOR_SHARE_URL` | Custom share portal URL |

---

## Best Practices

1. Use plan review BEFORE the agent starts coding — catch wrong approaches early
2. Keep each annotation tied to one concrete, actionable change
3. Include acceptance criteria in "request changes" feedback
4. For diff review, annotate exact line ranges tied to expected behavior changes
5. Use image annotation for UI/UX feedback where text is insufficient

---

## References

- [GitHub: backnotprop/plannotator](https://github.com/backnotprop/plannotator)
- [Official site: plannotator.ai](https://plannotator.ai)
- [Detailed install: apps/hook/README.md](https://github.com/backnotprop/plannotator/blob/main/apps/hook/README.md)

Overview

This skill enables visual review and structured feedback for AI-generated implementation plans and git diffs using Plannotator. It adds inline annotations, lets reviewers approve or request changes, and returns machine-readable feedback to the coding agent. The workflow supports pre-implementation safety checks and iterative approval loops.

How this skill works

Install the Plannotator CLI and connect it to your coding agent integration (Claude Code, OpenCode, or other supported CLIs). Run the review flow to open a visual diff or plan view, add annotation types like delete/insert/replace/comment, and submit either Approve or Request changes. The tool converts annotations into structured feedback the agent can act on and enforces explicit acceptance criteria when present.

When to use it

  • Before implementation to validate an AI-generated plan or roadmap for code changes
  • When you need visual, line-level annotations on a git diff with actionable guidance
  • To run an approval loop: accept a plan or send structured revision requests back to the agent
  • When integrating with Claude Code or OpenCode and you want plugin-based review hooks
  • For remote or containerized sessions where a fixed port and remote mode are required

Best practices

  • Annotate with one clear decision per comment to avoid ambiguity for the agent
  • Include explicit acceptance criteria (tests, lint rules, performance targets) in annotations
  • Prefer small, actionable edits over broad rewrites to make agent responses precise
  • Annotate exact line ranges for diffs so behavioral changes are linked to code
  • Use the Approve/Request changes outcome to drive the agent’s next planning step

Example use cases

  • Review a proposed refactor plan and mark risky steps for deletion or replacement
  • Annotate a pull request diff with insertions to add missing validation and tests
  • Approve an implementation plan after ensuring all acceptance criteria are met
  • Request structured revisions from a coding agent when a plan misses edge cases
  • Run reviews in a remote devcontainer by setting remote mode and a fixed port

FAQ

How does Plannotator send feedback back to my coding agent?

Plannotator converts annotations into structured feedback that is returned via the agent integration hooks; use Approve or Request changes to control the agent’s next action.

Can I review diffs line-by-line?

Yes. Annotate exact line ranges in a diff and label them as delete, insert, replace, or comment to tie feedback to specific behavior changes.