Agent skill

Review Refiner

by techygarg in techygarg/lattice

Facilitate a structured conversation to customize how the review molecule works -- atom loading rules, severity classification, report format, scope rules, insight capture, and health logging.

MITAuto-check passedDevelopment

Install Review Refiner

skills CLI
$ npx skills add techygarg/lattice --skill review-refiner -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install techygarg/lattice review-refiner --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/techygarg/lattice.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/review-refiner .claude/skills/review-refiner && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
review-refiner
GitHub stars
199
Token cost
~3.2k tokens
SKILL.md length
1,703 words
Files
2 (incl. assets)
Skills in repo
33
Repo updated
First seen
Licence
MIT

At a glance

Facilitate a structured conversation to customize how the review molecule works -- atom loading rules, severity classification, report format, scope rules, insight capture, and health logging.

  • Works in 3 steps: Read .lattice/config.yaml — does… → If yes, read that file. Ask the user → If no config or no existing document,…
  • The user says customize review
  • SKILL.md covers What This Produces, Before You Begin, Choosing the Mode and Facilitation Approach, plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Review Refiner is an agent skill from techygarg/lattice. Facilitate a structured conversation to customize how the review molecule works -- atom loading rules, severity classification, report format, scope rules, insight capture, and health logging. Produces a formal review-standards.md document that the review molecule will use as its process configuration. Use when the user says 'customize review', 'configure review', 'review preferences', 'review settings', 'change review process', or 'set up review'.

Its SKILL.md is about 3.2k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files, including assets (for example `assets/template.md`).

It sits in Development. The repository describes itself as: Install engineering discipline into any AI coding assistant. Composable skills for design, implementation, review, and team standards. Better process, not just better prompts. The licence is MIT.

When your agent uses it

  • The user says customize review
  • Configure review
  • Review preferences
  • Review settings

Example prompts

  • “customize review”
  • “configure review”
  • “review preferences”
  • “/review-refiner”

Workflow steps

3 steps, taken from the first numbered list in SKILL.md.

  1. Read .lattice/config.yaml — does paths.review_standards point to a file?
  2. If yes, read that file. Ask the user
  3. If no config or no existing document, proceed with the full interview flow.

What it can do on your machine

Read from SKILL.md and the folder at commit ed226a0. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are yaml).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Review Refiner loads about 3.2k tokens when it runs. Until then it costs about 117 tokens; SKILL.md has 1,703 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~117
When it runs · the whole SKILL.md, loaded when a task matches
~3.2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from techygarg/lattice at commit ed226a0, republished under its MIT licence (© techygarg). 1,703 words, ~3,245 tokens.

Download SKILL.mdSave it as .claude/skills/review-refiner/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
review-refiner
description
Facilitate a structured conversation to customize how the review molecule works -- atom loading rules, severity classification, report format, scope rules, insight capture, and health logging. Produces a formal review-standards.md document that the review molecule will use as its process configuration. Use when the user says 'customize review', 'configure review', 'review preferences', 'review settings', 'change review process', or 'set up review'.

Review Refiner

What This Produces

  • Output: .lattice/standards/review-standards.md (or custom path from .lattice/config.yaml → paths.review_standards)
  • Two modes:
    • Overlay (mode: overlay): A slim document containing only sections that differ from the defaults. The review molecule reads its embedded defaults first, then applies this document's sections on top. This is the expected common case.
    • Override (mode: override): A comprehensive standalone document that fully replaces the molecule's embedded defaults. For teams with fundamentally different review processes.
  • Default mode: Overlay -- produces only what the user wants to change
  • Config key: paths.review_standards in .lattice/config.yaml
  • Consumed by: The review molecule (NOT an atom -- this is the first molecule-level config)
  • Template: Read ./assets/template.md for the full document structure, default content, and interview guidance comments
Scope Clarification

This refiner configures the review process -- how the review molecule orchestrates atom output. It does NOT configure what atoms check for.

Belongs here (process orchestration)Belongs in atom refiners (quality standards)
Which atoms load and whenWhat checks an atom runs
Severity level definitionsWhat constitutes a violation
Report format and groupingChecklist items and anti-patterns
Delta scope rulesLayer definitions, naming rules
Insight capture preferencesDomain modeling rules
Health log formatSecurity check thresholds
Custom review dimensionsAtom-specific validation logic

If a user asks about changing what an atom checks for, redirect them to the appropriate atom refiner (architecture-refiner, clean-code-refiner, ddd-refiner).

Before You Begin

Check for existing documents

Before starting the interview, check whether a custom document already exists:

  1. Read .lattice/config.yaml — does paths.review_standards point to a file?
  2. If yes, read that file. Ask the user:
    • "You already have a review standards document. Would you like to revise it (update specific sections), start fresh (new interview), or add to it (add new sections)?"
    • Revise: Load the existing document, walk through only the sections the user wants to change, and update in place.
    • Start fresh: Proceed with the full interview flow below.
    • Add to it: Skip to the sections the user wants to add (e.g., custom dimensions).
  3. If no config or no existing document, proceed with the full interview flow.
Scan for context

Look for signals that inform the conversation:

  • Existing review history: Check .lattice/reviews/review-log.md — what atoms have been loading? What severity patterns exist? Are there recurring findings?
  • Existing learnings: Check .lattice/learnings/operational-learnings.md — what patterns have been captured? Is the file growing dense in any category?
  • Project structure: What does the codebase look like? Are there directories that should be excluded or always-scanned?
  • Existing atom refiners: Which atom refiners have been run? (Check .lattice/config.yaml for paths.architecture, paths.clean_code, paths.ddd_principles) This tells you which atoms the team cares about.

Share relevant findings with the user at the start: "I looked at your review history and noticed [patterns]. I'll use that as context for our conversation."

If the project is new with no review history, proceed with defaults as the starting point.

Choosing the Mode

The first decision in the conversation. Present the three options:

"How would you like to configure your review process?

  1. Customize specific sections (overlay) — Keep the defaults and change only what differs for your project. This produces a slim document. Most teams choose this.
  2. Define everything from scratch (override) — Walk through all sections and produce a comprehensive standalone document.
  3. Add project-specific sections only (overlay with additions) — Keep all defaults as-is and add new sections for your team's specific rules (e.g., custom review dimensions).

The defaults cover a solid review workflow. Option 1 is recommended unless your review process needs to be fundamentally different."

Map the choice:

  • Options 1 and 3 → mode: overlay
  • Option 2 → mode: override

Facilitation Approach

Conversation style
  • One section at a time. Do not dump all questions at once. Walk through the template sequentially.
  • Defaults-first. For each section, briefly summarize the default, then ask if it matches. Do not read the entire default verbatim -- summarize the key points and ask.
  • Record decisions, not discussion. The output document reads as a specification, not meeting notes. "We discussed X and decided Y" is wrong. "Y" is right.
  • Probe, don't interrogate. Use the probing questions in the template guidance comments as follow-ups when the user's answer is ambiguous, not as a checklist.
For overlay mode

This should be fast. Many sections will be "keep as-is."

  1. Present each section's default briefly (a 2-3 sentence summary, not full content).
  2. Ask: "Does this match your project, or would you like to change it?"
  3. If the user says it matches → skip it (section will NOT appear in the output).
  4. If the user wants changes → dive into that section, discuss the specifics, record the changes.
  5. At the end, ask: "Any additional review process preferences you'd like to add?" (e.g., custom dimensions, extra report sections).
  6. Only sections the user changed or added appear in the output document.
For override mode

This is thorough. Every section gets attention and appears in the output.

  1. Walk through every section in full detail.
  2. User confirms, modifies, or replaces each section.
  3. All sections appear in the output -- defaults for unchanged ones, user's version for changed ones.
Common scenarios
  • "I agree with everything" → No custom document needed. Tell the user: "The embedded defaults are already active and match your preferences. No custom document is needed — the review molecule will use the defaults automatically."
  • "I want security checks on every review" → Overlay §1 only: move secure-coding from conditional to always-loaded.
  • "I want stricter severity for security findings" → Overlay §1 + §2 (atom loading is coupled with per-atom severity overrides).
  • "We want to exclude generated code from reviews" → Overlay §4 only: add directory exclusion.
  • "We want performance checks in reviews" → Overlay §7 only: add a Performance Patterns custom dimension.
  • "We want a different report format" → Overlay §3 only: adjust grouping, format, or toggle "What's done well."
  • "Our insights file is getting too big" → Overlay §5 only: adjust pruning threshold or add categorization.

Section-by-Section Interview Guide

Read ./assets/template.md and follow the <!-- INTERVIEW GUIDANCE: --> comments for each section. Those comments contain the specific questions to ask, probing questions, and what is customizable vs fixed.

Show full SKILL.md (717 more words)Show less
Cross-section dependency table

Decisions in early sections affect later sections. When a user changes an early section, flag the dependent sections:

Decision inAffectsHow
§1 Atom Loading§2, §3, §5, §6Per-atom severity overrides reference atom names; report sections map to loaded atoms; insight categories follow atoms; log atom names must match
§2 Severity§3, §5, §6, §7Report ordering follows severity levels; capture criteria reference severity; log counts use severity names; custom dimensions need severity assignment
§4 Scope Rules§1, §7Expanded scope may trigger more conditional atoms; custom dimensions follow scope rules
§7 Custom Dimensions§2, §3Custom dimensions contribute findings needing severity classification and report placement

When a dependency is triggered, inform the user: "Since you changed [X], we should also review [Y] — it's affected by that decision."

Overlay-specific section flow

For each of the 7 default sections:

  1. Summarize the section's key points in 2-3 sentences.
  2. Ask: "Does this match your project?"
  3. Yes → Move to the next section. This section will not appear in the output.
  4. No → Dive into the section details using the template guidance. Produce the user's version.
  5. After all 7 sections, ask about new sections.
  6. Only sections the user changed or added appear in the output document.
Override-specific section flow

For each of the 7 default sections:

  1. Present the section's full content.
  2. Ask: "Does this work as-is, or would you like to modify it?"
  3. As-is → Include the default content in the output unchanged.
  4. Modify → Discuss changes, produce the modified version.
  5. After all 7 sections, ask about new sections.
  6. All sections go in the output.

Output Assembly

For overlay mode
  1. YAML frontmatter: mode: overlay
  2. Overlay preamble text (from template)
  3. Table of contents listing only the included sections
  4. Only the sections the user changed or added
  5. Each section must be self-contained — it is a complete replacement of that section in defaults. Do not write diffs or partial sections.
  6. Section headings must match the template exactly (the review molecule matches sections by heading)
  7. New sections (§8+) are included after the default sections
  8. Footer with project name, date, mode
For override mode
  1. YAML frontmatter: mode: override
  2. Override preamble text (from template)
  3. Full table of contents (all 7+ sections)
  4. All sections: defaults for unchanged, user's version for changed, new sections at the end
  5. Footer with project name, date, mode
For both modes

Strip all <!-- INTERVIEW GUIDANCE: --> comments from the output. The final document is a clean specification.

Determine output path:

  1. If .lattice/config.yaml exists and has paths.review_standards, use that path.
  2. Otherwise, default to .lattice/standards/review-standards.md.

Write the document:

  1. Create .lattice/standards/ directory (and .lattice/ parent) if it does not exist.
  2. Write the document to the determined path.

Update config:

  1. If .lattice/config.yaml does not exist, create it with:
    yaml
    paths:
      review_standards: .lattice/standards/review-standards.md
  2. If .lattice/config.yaml exists but has no paths.review_standards, add the key. Preserve all existing content.
  3. If .lattice/config.yaml exists and already has the key, no config change needed.

Confirm to user: "Your review standards document has been written to [PATH] in [overlay|override] mode. The review molecule will now use it [on top of the defaults | instead of the defaults] when running reviews."

Document Quality Checks

Before writing the final document, verify:

Overlay mode checks
  • Each included section is self-contained and complete (not a diff or partial section)
  • Section headings match the template exactly (for section matching by the review molecule)
  • No <!-- INTERVIEW GUIDANCE: --> comments remain
  • Frontmatter has mode: overlay
  • Only changed/added sections are included — unchanged sections are omitted
  • Per-atom severity overrides reference atoms that are actually loadable (§1 ↔ §2 consistency)
  • Custom dimension severity levels exist in §2's severity list (§7 ↔ §2 consistency)
Override mode checks
  • Every section from the template is present (§1 through §7, plus any new sections)
  • Severity levels are consistent throughout all sections
  • Per-atom overrides reference valid atom names
  • Custom dimensions use severity levels defined in §2
  • Report preferences reference valid grouping strategies
  • No <!-- INTERVIEW GUIDANCE: --> comments remain
  • Frontmatter has mode: override
  • Document is readable as a standalone specification
Both modes
  • Frontmatter is valid YAML with correct mode value
  • Document is well-formatted markdown
  • Config file (.lattice/config.yaml) is correctly updated
  • Output path exists and is writable
  • Cross-section dependencies are consistent (atom names, severity levels, categories)

© techygarg, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file (assets) in skills/review-refiner of techygarg/lattice.

  • SKILL.md
  • assets/template.md

Open the folder on GitHubat commit ed226a0

Compare with similar skills

Review Refiner next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Review Refiner compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Review Refiner this skilltechygarg/lattice199—~3.2kAutomated safety check: PassMIT
Vercel Composition Patternssupabase/supabase111k58 repos~726Automated safety check: PassMIT
Finishing a Development Branchobra/superpowers297k5 repos~1.9kAutomated safety check: PassMIT
Typescript Advanced Typesrolling-scopes/rsschool-app10k25 repos~4.2kAutomated safety check: PassMPL-2.0
PR Babysitteropeninterpreter/openinterpreter69k3 repos~4.2kAutomated safety check: PassApache-2.0
Code Review ChecklistshareAI-lab/learn-claude-code78k4 repos~1.1kAutomated safety check: PassMIT

Similar skills

  • Official

    React composition patterns that scale. An agent skill from supabase/supabase.

    111k GitHub starsUsed in 58 repos~726 tokens
    DevelopmentAuto-check passed
  • Walks the last step of a branch: confirm tests pass, detect the git environment, ask how to integrate, carry out your choice and clean up the worktree.

    297k GitHub starsUsed in 5 repos~1.9k tokens
    DevelopmentAuto-check passed
  • Typescript Advanced Types

    rolling-scopes/rsschool-app

    Master TypeScript's advanced type system including generics, conditional types, mapped types, template literals, and utility types for building type-safe applications.

    10k GitHub starsUsed in 25 repos~4.2k tokens
    DevelopmentAuto-check passed
  • PR Babysitter

    openinterpreter/openinterpreter

    Watches an open GitHub pull request until it merges, handling review comments, diagnosing CI failures and retrying flaky checks along the way.

    69k GitHub starsUsed in 3 repos~4.2k tokens
    DevelopmentAuto-check passed
  • Code Review Checklist

    shareAI-lab/learn-claude-code

    Reviews code against a five-part checklist covering security, correctness, performance, maintainability and testing, and reports findings in a fixed format.

    78k GitHub starsUsed in 4 repos~1.1k tokens
    DevelopmentAuto-check passed
  • Greploop

    onyx-dot-app/onyx

    Iteratively improves a PR (GitHub), MR (GitLab), or shelved changelist (Perforce) until Greptile gives it a 5/5 confidence score with zero unresolved comments.

    32k GitHub starsUsed in 4 repos~3.3k tokens
    DevelopmentAuto-check passed

More from techygarg/lattice

All 33 skills in this repo
  • Architecture Compass

    techygarg/lattice

    Architectural thinking partner for an existing repository — scans the codebase, conducts a structured interview, agrees on current architectural state and recommended direction, and produces a…

    199 GitHub stars~4.6k tokensUpdated today
    Auto-check passed
  • Lattice Init

    techygarg/lattice

    Guided setup and upgrade-check experience for Lattice projects -- scans the repository, detects existing configuration and outdated conventions, suggests refiners and available upgrades in priority…

    199 GitHub stars~3.3k tokensUpdated today
    Auto-check passed
  • Skill Align

    techygarg/lattice

    Audit and fix all Lattice documentation, README, docs/, PROJECT.md, GitHub issue templates, and CLAUDE.md to ensure they are fully aligned with the current skill inventory.

    199 GitHub stars~2k tokensUpdated today
    Auto-check passed
  • Skill Validate

    techygarg/lattice

    Validate any Lattice SKILL.md against all tier conventions — atoms, molecules, and refiners.

    199 GitHub stars~1.5k tokensUpdated today
    Auto-check passed
  • Architecture Refiner

    techygarg/lattice

    Facilitate a structured conversation to define architecture principles for a repository.

    199 GitHub stars~3.7k tokensUpdated today
    Auto-check passed
  • Clean Code Refiner

    techygarg/lattice

    Facilitate a structured conversation to define clean code principles for a repository.

    199 GitHub stars~3k tokensUpdated today
    Auto-check passed

Categories

Questions about Review Refiner

What does Review Refiner do?

Facilitate a structured conversation to customize how the review molecule works -- atom loading rules, severity classification, report format, scope rules, insight capture, and health logging. Review Refiner is an agent skill from techygarg/lattice. Facilitate a structured conversation to customize how the review molecule works -- atom loading rules, severity classification, report format, scope rules, insight capture, and health logging.

When should I use Review Refiner?

Review Refiner fits situations like: the user says customize review; configure review; review preferences; review settings.

How do I install Review Refiner in Claude Code?

Run `npx skills add techygarg/lattice --skill review-refiner -a claude-code`. Or copy the skill folder (skills/review-refiner in techygarg/lattice) into .claude/skills/review-refiner in your project. Claude Code loads it when a task matches its description.

How do I install Review Refiner in Codex?

Run `npx skills add techygarg/lattice --skill review-refiner -a codex`. Or copy the skill folder (skills/review-refiner in techygarg/lattice) into .agents/skills/review-refiner in your project. Codex loads it when a task matches its description.

Can I use Review Refiner in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add techygarg/lattice --skill review-refiner -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/review-refiner, .gemini/skills/review-refiner, .github/skills/review-refiner and .opencode/skills/review-refiner in your project.

What does Review Refiner need to run?

SKILL.md names no scripts, command-line tools or credentials: Review Refiner is instructions for the agent only.

Does Review Refiner access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Review Refiner safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Review Refiner use?

Review Refiner is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Review Refiner use?

About 3.2k tokens (SKILL.md is roughly 13k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Review Refiner?

Skills that share tags, products or a category with Review Refiner: Vercel Composition Patterns (supabase/supabase, 111k stars), Finishing a Development Branch (obra/superpowers, 297k stars), Typescript Advanced Types (rolling-scopes/rsschool-app, 10k stars) and PR Babysitter (openinterpreter/openinterpreter, 69k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Review Refiner?

techygarg (a GitHub user) maintains it in techygarg/lattice, which has 199 GitHub stars. The repository holds 33 skills in this directory. The repository was last updated on October 10, 2026.

Source: techygarg/lattice on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.