Back to search
critique
SkillWorks with Claude CodeGitHub
Adversarial review of a plan, design doc, code, or project — like a lawyer reviewing a contract on the user's behalf. Use when the user wants a skeptical second opinion before committing to an approach.
Safety scan
A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.
Checked today
Badge for your README
Markdown
[](/listings/francesco-plt--opencode-skill-critique)HTML
<a href="/listings/francesco-plt--opencode-skill-critique"><img src="/api/listings/francesco-plt--opencode-skill-critique/badge.svg" alt="findsafeskills safety rating" /></a>Install
i
Install instructions from the README
As written by the repo's author. findsafeskills has not verified these steps.
git clone https://github.com/<your-username>/opencode-skill-critique ~/.config/opencode/skills/critique
(Adjust the destination if your OpenCode config lives elsewhere.)
What was scanned
The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.
SKILL.md · Manifest · 88 lines
- ---
- name: critique
- description: Adversarial review of a plan, design doc, code, or project — like a lawyer reviewing a contract on the user's behalf. Use when the user wants a skeptical second opinion before committing to an approach.
- license: MIT
- ---
- You are orchestrating an adversarial critique from main conversation context. You handle target resolution, spawning, archival, and the final triage. The actual critique work happens in a single nested subagent via the `subagent` tool, independent of your conversation history.
- The reviewer prompt lives at `~/.config/opencode/skills/critique/critique_prompt.md`.
- **Arguments:** whatever text the user passed after invoking this skill (e.g. "model=anthropic/claude-opus-4 the plan", "model=opus path/to/file.py", or a bare target). Call this `$ARGUMENTS`.
- ## 1. Parse arguments
- Inspect the first whitespace-delimited token of `$ARGUMENTS`:
- - If it starts with `model=`, use the value after `model=` as the model override and the rest of the string as the raw review target.
- - Otherwise, the whole `$ARGUMENTS` is the raw review target and no model override is given; use the default top-tier model.
- Call the resulting raw target string **TARGET**.
- ## 2. Resolve TARGET to a concrete reference
- You are in main conversation context — use it. The spawned subagent will not have this advantage.
- - If TARGET names a specific file path, commit range, or other unambiguous reference → use as-is.
- - If TARGET is vague ("the plan", "the latest plan", "the design doc", "the recent commit", "recent changes") → resolve from conversation history first (OpenCode has no `~/.claude/plans/` equivalent — there is no fixed plan-file directory to scan, so conversation context is the only source of truth for "the plan").
- - If TARGET is empty or conversation history doesn't disambiguate → fall back: `git log --oneline -5` and any `.design/*.md` files (mtime-sorted) in the current repo; pick the newest. If nothing resolves, ask the user rather than guessing (see Notes).
- Resolve to one concrete TARGET string before spawning. The critic works better with an unambiguous target than with "go find it."
- ## 3. Prepare the subagent prompt
- Read `~/.config/opencode/skills/critique/critique_prompt.md` once. The full text of that file, followed by an appended `\n\nYour review target: <TARGET>\n`, is the prompt you'll pass to the critic.
- ## 4. Spawn the critic
- Use the `subagent` tool:
- - `agent`: `"general"`
- - `description`: short, e.g. `"Critique <short target name>"`
- - `model`: the model override if given; otherwise let it use the session's configured top-tier model — do not downgrade to a cheap tier for this
- - `prompt`: the prepared prompt (critique_prompt.md text + appended target line)
- The subagent will read whatever files TARGET requires, form findings, and return a final report. Take its final message verbatim as the critique.
- ## 5. Archive
- After the critic returns, save to `~/.config/opencode/skills/critique/runs/<timestamp>-<slug>.md`:
- - `mkdir -p ~/.config/opencode/skills/critique/runs` first.
- - Timestamp: ISO 8601 with colons replaced by hyphens (filesystem-safe). Example: `2026-05-14T17-30-00`.
- - Slug: TARGET lowercased, non-alphanumerics replaced with hyphens, collapsed runs of hyphens, max 40 chars.
- - Contents: a header noting target / model / timestamp; then the critique.
- If the critic failed (the subagent call returned an error), still archive what you got — the failure is a useful record.
- ## 6. Reply to the user
- Compose your final reply in this order:
- 1. **Archive notice** — one line: `> Critique archive: <full path>`
- 2. **Critique verbatim** under `## Critique`.
- 3. **Your `## Triage` section.** This is the main-context payoff. You have:
- - The full critique result
- - Your conversation context (what was discussed, what the user values, what was just generated)
- - `read`/`grep`/`shell` to verify specific claims
- ### Triage instructions
- For each distinct finding in the critique:
- 1. **Independent verification.** For claims that name a file:line, function name, or specific behavior, use `read` / `grep` / `shell` to check the code yourself. The critic gave its best read; you can confirm or refute directly.
- Categorize each finding as one of:
- - **Worth fixing.** Real issue with concrete benefit. Say whether it's small enough to do now or worth deferring.
- - **Matter of taste / judgment call.** Could go either way; not wrong, but not clearly right either. State the tradeoff in one sentence.
- - **Wrong.** Name what the critic claimed, what's actually true, and how you verified it (file:line, grep result, command output). If you can't verify and you're just disagreeing on intuition, mark it "I disagree but haven't verified" — the user wants to know when you're hedging rather than taking a hedged claim at face value.
- Be explicit when uncertain. A confident-wrong triage is worse than a hedged-uncertain one. If a finding doesn't fit cleanly into the three buckets, say so rather than forcing it.
- Do NOT propose code edits in the triage. Triage is decision support; edits come after the user picks which findings to act on.
- ## Notes
- - Subagents return only their final report; their intermediate tool calls and reasoning stay in their own session, not yours.
- - If the user runs this skill with no arguments and you can't resolve a TARGET from conversation history or the `git log`/`.design/` fallback, explain the ambiguity and ask rather than picking blindly.
README.md · README · 79 lines
- # critique (OpenCode fork)
- An [OpenCode skill](https://opencode.ai) that performs adversarial review of plans, design docs, code, or projects — like a lawyer reviewing a contract on your behalf.
- This is a fork of [dlowd/claude-skill-critique](https://github.com/dlowd/claude-skill-critique), ported to run under [OpenCode](https://opencode.ai) instead of Claude Code. The design, prompts, and behavior are kept as close to the original as the platform allows — see [Porting notes](#porting-notes) for the handful of differences.
- ## What it does
- When invoked, it spawns a fresh-eyes critic subagent to review the target material (code, design doc, recent commits, a plan discussed earlier in the conversation), archives the run, and then synthesizes the findings into a triage your conversation can act on.
- The critic reports findings ranked by severity:
- 1. **Showstoppers** — fundamentally wrong approaches, security issues, architectural mistakes
- 2. **Gaps** — missing error handling, unhandled edge cases, deferred decisions
- 3. **Inconsistencies** — contradictions between sections, shifting terminology
- 4. **Underspecified areas** — ambiguities where an implementer might guess wrong
- 5. **Suggestions** — simpler approaches, unnecessary complexity
- 6. **What looks good** — brief note on what's solid (calibrates trust)
- By default the critic runs on the session's configured top-tier model. You can override the model per invocation (e.g. to compare how a different model critiques the same target) — see Usage below.
- Every run is archived to `runs/<timestamp>-<slug>.md` for later reference.
- The skill auto-detects the target from arguments you pass, falling back to conversation context (e.g. "the latest plan" → the plan discussed earlier in this session) and then to disk-scan heuristics (`git log`, `.design/*.md`).
- ## Install
- ```bash
- git clone https://github.com/<your-username>/opencode-skill-critique ~/.config/opencode/skills/critique
- ```
- (Adjust the destination if your OpenCode config lives elsewhere.)
- ## Prerequisites
- - **OpenCode.** This is an OpenCode skill — it runs inside OpenCode, not standalone.
- ## Usage
- In OpenCode, load the skill and pass your target as the argument, e.g.:
- ```
- critique # default top-tier model, auto-detect target
- critique path/to/file.py # default model, specific file
- critique "use of ffmpeg" # default model, topic across the codebase
- critique "commits from today" # default model, recent changes
- critique model=opus path/to/file.py # override the critic's model
- critique model=anthropic/claude-opus-4 "the plan" # override with a fully-qualified model id
- ```
- ## Design principles
- - **Be specific** — reference exact files, lines, and decisions, not vague "could be better"
- - **Be honest about severity** — don't inflate minor issues to fill a list
- - **Identify problems, don't rewrite** — the user wants to know what's wrong
- - **Speculative findings must name a mechanism** — "this might be slow" isn't enough; name what breaks and how
- - **Intentional decisions can still be wrong** — deliberateness doesn't get a pass
- ## Customization
- The skill is two files in `~/.config/opencode/skills/critique/`:
- - `SKILL.md` — orchestration (argument parsing, target resolution, critic spawning, archive, triage). Edit to change how the skill runs.
- - `critique_prompt.md` — the reviewer-persona prompt the critic reads. Edit to change severity categories, ground rules, output format, or the lawyer-reviewing-a-contract framing.
- Fork the repo and adjust whichever matches your intent.
- ## Porting notes
- This fork keeps the original's structure and behavior intact, with these differences from upstream:
- - **Agent spawning**: uses OpenCode's `subagent` tool (`agent: "general"`) instead of Claude Code's `Agent` tool/`subagent_type: general-purpose`.
- - **No fixed plan-file directory**: Claude Code's plan mode writes to `~/.claude/plans/`; OpenCode has no equivalent, so "the plan" resolves from conversation context or `.design/*.md` / `git log` only.
- - **Project-context file**: checks `AGENTS.md` first (falling back to `CLAUDE.md` if present) instead of only `CLAUDE.md`.
- - **Single critic only**: upstream also supported a Codex-CLI critic (solo or alongside the Opus critic, with cross-critic triage). This fork drops the Codex path entirely and keeps a single subagent critic with an optional `model=` override instead, since OpenCode's subagent model selection already covers the "compare models" use case without the extra bash-helper/sandbox machinery.
- ## License
- MIT
Ratings and comments
Sign in to rate this skill.
Sign inFree to use. If it’s helped, pass it on.