show-changes

Present completed work to the human for optional review via the ai-review desktop app. Use when you've finished a task and want the human to see what you did — they can optionally leave feedback.

5 stars

Best use case

show-changes is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Present completed work to the human for optional review via the ai-review desktop app. Use when you've finished a task and want the human to see what you did — they can optionally leave feedback.

Teams using show-changes should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/show-changes/SKILL.md --create-dirs "https://raw.githubusercontent.com/mrmans0n/ai-review/main/skills/show-changes/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/show-changes/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How show-changes Compares

Feature / Agentshow-changesStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Present completed work to the human for optional review via the ai-review desktop app. Use when you've finished a task and want the human to see what you did — they can optionally leave feedback.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

You have completed a task and want to show the human what you did. Open ai-review so they can look over the changes and optionally leave feedback. This is less formal than a full code review — the framing is "here's what I did" rather than "please review my code."

## Steps

1. **Determine what to show.** Check these in priority order to pick the right `air` invocation:

   a. **Uncommitted changes exist** (staged or unstaged, check via `git status --porcelain`):
      Run `air --wait --json` with no branch/commit flags. This shows the working directory diff.

   b. **All changes committed, on a gg stack branch** — the current branch matches the `user/name` pattern (no `--` in the name part) and `.git/gg/config.json` exists:
      Read the gg base branch from config (parse `defaults.base`, fall back to `main`). Run:
      ```
      air --wait --json --commits <gg-base>..HEAD
      ```
      This shows the full stack diff, matching what ai-review displays when opening a gg stack.

   c. **All changes committed, on a feature branch** (not main/master):
      Determine the base branch (`main` or `master`, whichever exists). Run:
      ```
      air --wait --json --branch <base-branch>
      ```

   d. **All changes committed, on main/master itself:**
      Identify the first commit you made during this session. If you can determine the exact commit, use that hash directly. Otherwise, fall back to the first unpushed commit: run `git log origin/main..HEAD --oneline --reverse` (or `origin/master`) and take the first commit hash. Run:
      ```
      air --wait --json --commit <first-relevant-commit-hash>
      ```

   e. **None of the above:** Run `air --wait --json` with no flags (empty diff — the app handles it).

   The `air --wait --json` command opens the ai-review desktop app and blocks until the human submits. They may add comments or submit with no comments. The output is structured JSON.

2. **Handle the response.**

   - **If the human submitted comments:** Parse the JSON feedback. The output has the shape:

     ```json
     {
       "format": "ai-review.feedback/v1",
       "context": { "mode": "...", ... },
       "comments": [
         { "id": "...", "file": "...", "startLine": 10, "endLine": 12, "side": "old|new", "text": "...", "createdAt": "..." }
       ]
     }
     ```

     Address each comment: read the referenced file and lines, make the requested change. If a comment is unclear, use your best judgment.

   - **If the human submitted with no comments:** (empty `comments` array) Acknowledge that they've seen the changes and move on.

3. **Summarize.** If changes were made, provide a concise summary listing each comment and what you did to address it.

## Notes

- If `air` is not found, tell the user to install via `brew install --cask mrmans0n/tap/ai-review` (macOS) or build from source at https://github.com/mrmans0n/ai-review.
- If the diff is empty, inform the user there are no changes to show.
- Do NOT commit after making changes — let the user decide when to commit.

Related Skills

review-commits

5
from mrmans0n/ai-review

Open existing commits in the ai-review desktop app for review. Use when you need to review, understand, or get feedback on specific commits, a commit range, or a branch diff — not your own recent work, but existing history.

human-review

5
from mrmans0n/ai-review

Request human code review via the ai-review desktop app. Use when code changes are complete and ready for a final human review before committing or merging. Opens an interactive diff viewer where the human can leave inline comments, then returns their feedback.

browse-diff

5
from mrmans0n/ai-review

Open the ai-review desktop app to visually browse a diff. Use when the user wants to see changes in a visual diff viewer without a review feedback loop — just for viewing.

showroom:verify-content

12
from rhpds/rhdp-skills-marketplace

This skill should be used when the user asks to "verify my workshop content", "review my lab module", "check my Showroom content", "validate my AsciiDoc module", "quality check my demo", "review my workshop for Red Hat standards", or "run a content review on my lab".

showroom:create-lab

12
from rhpds/rhdp-skills-marketplace

This skill should be used when the user asks to "create a lab module", "write a workshop module", "build a Showroom lab", "convert docs to a lab", "write a hands-on exercise", "create an AsciiDoc module", or "turn this documentation into a lab exercise".

showroom:create-demo

12
from rhpds/rhdp-skills-marketplace

This skill should be used when the user asks to "create a demo module", "write a Know/Show demo", "build a presenter demo", "create a Showroom demo", "write a facilitator guide", "build a demo script", or "create a presenter-led demo for RHDP".

showroom:blog-generate

12
from rhpds/rhdp-skills-marketplace

This skill should be used when the user asks to "turn this lab into a blog post", "write a blog post from this module", "generate a blog from my Showroom content", "convert my workshop to a blog", "write a Red Hat Developer blog post", or "create a blog post from my demo".

rulebook-task-show

11
from hivellm/rulebook

Show complete details of a Rulebook task including proposal, checklist, design, and specs. Use to understand task requirements before implementation.

rulebook-skill-show

11
from hivellm/rulebook

Show detailed information about a specific skill including metadata, content preview, and enabled status. Use to inspect a skill before enabling it.

tracking-regulatory-changes

11
from CaseMark/skills

Monitors regulatory developments with impact assessment, gap analysis, and implementation timeline planning. Use when tracking regulatory changes, assessing compliance gaps, or planning implementation.

managing-accounting-policy-changes

11
from CaseMark/skills

Evaluates new accounting standard impacts with transition planning and disclosure preparation. Use when implementing new standards, assessing ASU impacts, or planning accounting transitions.

managing-investor-roadshow-logistics

11
from CaseMark/skills

Coordinates roadshow scheduling with institutional investor targeting, presentation materials, and feedback tracking. Use when managing roadshows, organizing investor meetings, or tracking investor engagement.