v1.17.0 Now Available for Claude Code

The full review → ship → QA → fix loop, in one plugin

Candid runs structured code review, ships your branch, QAs the live app in real Chrome, and turns findings into PRs — all from inside Claude Code.

One config. Your standards. Your tone. Your gates.

Get Started in 5 minutesLearn how it works →
npx skills add https://github.com/ron-myers/candid
SEE IT IN ACTION

What a review actually looks like

Candid review command activation showing the review process steps

Run /candid-review to start a comprehensive code review

Apply fix dialog showing individual fix application options

Review and apply fixes individually with one click

Fix handling options showing batch operation choices

Choose how to handle multiple fixes at once

Features

Review

Technical.md

Write your standards in markdown. /candid-init generates them from your codebase.

Focus Modes

Review only what matters: --focus security, performance, architecture, edge-case.

Tone Selection

--harsh says it straight. --constructive cares but doesn't soften. Set the default in config.

Re-Review

--re-review diffs against your last pass. See what's fixed, what's still broken, what's new.

Decision Register

Answers persist. The same question never asks twice — across reviews, across sessions.

Ship

Auto-Commit

--auto-commit commits applied fixes with messages that list every change and its severity.

Configurable Ship Pipeline

Install, build, test, review, PR, auto-merge, deploy hook — every step is opt-in via .candid/config.json.

Linear Integration

/candid-ship moves the linked Linear issue to In Review on PR open. State, prompt, and team prefixes are yours.

QA

Chrome QA

/candid-chrome-qa drives real Chrome — desktop and mobile — and writes findings as structured JSON.

Chrome QA Fix

Pick findings to fix. Batched PR, one PR per finding via Conductor, or file Linear issues — your call.

HOW IT WORKS

The loop

Install once. Then run the four commands that take a branch from review to shipped.

  1. Install + init.Add Candid to Claude Code, then generate a Technical.md tuned to your codebase.
    npx skills add https://github.com/ron-myers/candid
/candid-init
  2. Review.Tell Candid what kind of review you want — flags pick tone and focus, freeform text after sets the lens.
    /candid-review --harsh review this branch like a
  skeptical CTO — what would block a launch?
  3. Ship.Pipeline runs from .candid/config.json. Add intent for the review pass that gates the PR.
    /candid-ship double-check no secrets, no
  console.logs, no commented-out code before opening PR
  4. QA + fix.Drive real Chrome with a goal in plain English. Then pick findings to ship — batched PR, one PR per finding, or Linear issues.
    /candid-chrome-qa --goal "first-time signup flow" \
  --prompt "where would a new user get stuck?"

/candid-chrome-qa-fix --strategy batched fix the
  P0/P1 blockers, file the rest as Linear issues
CONFIG

One config file. Your whole pipeline.

Tone, focus, ship steps, fast-ship toggles, Linear — all in .candid/config.json. No CLI flag hunting.

{
  "tone": "harsh",
  "focus": "security",
  "exclude": ["*.generated.ts"],
  "ship": {
    "installCommand": "pnpm install",
    "buildCommand": "pnpm build",
    "testCommand": "pnpm test",
    "targetBranch": "stable",
    "autoMerge": true,
    "postMergeCommand": "curl -X POST $DEPLOY_HOOK",
    "issueTracker": {
      "provider": "linear",
      "enabled": true,
      "teamPrefixes": ["ENG"],
      "state": "In Review"
    }
  },
  "fastShip": {
    "build": true,
    "autoMerge": true
  }
}
  • tone: "harsh" — every /candid-review uses brutal honesty by default.
  • focus: "security" — reviews target security unless you override per-run.
  • ship.installCommand — runs before build on every /candid-ship.
  • ship.autoMerge: true — PR auto-merges once checks pass.
  • ship.postMergeCommand — deploy webhook fires after merge.
  • ship.issueTracker.enabled — Linear issue moves to In Review on PR open.
  • fastShip.build + autoMerge — /candid-fast-ship skips review and tests for trivial PRs.
See the full ship-config reference →
CHROME QA FLOW

Find the bug. Fix the bug. Ship the bug fix.

QA your running app, then turn findings into shipped fixes — without leaving Claude Code.

  1. QA your app — as a frustrated first-time user.Tell Candid who is walking the app. The persona shapes what counts as a finding — confused user, paranoid security engineer, fussy designer.
    /candid-chrome-qa --goal "signup → first action" \
  --prompt "walk this as a frustrated first-time user
  who has never seen the product. Where do you bounce?"
  2. Pick what to fix — as the engineer on call.Filter by severity, category, or persona. Pick the strategy: batched PR, one PR per finding, local-only, or issues-only.
    /candid-chrome-qa-fix --severity P0,P1 fix the
  blockers like an engineer on call — minimal diffs,
  no refactors, ship fast
  3. Ship it — as the PM filing the backlog.File a Linear issue per finding before touching code, then ship the PRs that link back. Re-runs dedup by ID.
    /candid-chrome-qa-fix --create-issues --strategy batched
  triage like a PM — group related findings, write
  user-facing titles, link back to the QA pass
SLASH COMMANDS
  • /candid-initGenerate Technical.md + .candid/config.json from your codebase.
  • /candid-reviewReview your changes. Pick tone (--harsh/--constructive) and focus area.
  • /candid-shipRun install/build/test, open the PR, optionally auto-merge and update Linear.
  • /candid-fast-shipMinimal ship — only steps you opted into in fastShip config run.
  • /candid-chrome-qaWalk your running app in real Chrome (desktop + mobile). Filter by route, severity, viewport.
  • /candid-chrome-qa-fixPick findings to fix. Batched PR, one PR per finding via Conductor, or Linear issues only.
  • /candid-validate-standardsLint your Technical.md for vague rules and linter overlaps.
COMMUNITY

Join the Conversation

Get help, share feedback, and connect with other Candid users.

Join our Slack
FREQUENTLY ASKED QUESTIONS
Does Candid work with any language?

Any language Claude Code reads. Your Technical.md standards can be language-specific or universal.

How does Candid pay for Claude Code?

It uses whatever Claude Code is already logged into — your API key, Pro, or Max plan. No separate billing.

Can my team share a config?

Commit Technical.md and .candid/config.json to your repo. Every teammate gets the same standards, tone, and ship pipeline automatically.

Harsh vs. Constructive — what's the difference?

Harsh is brutally honest — best for catching what you'd defend if asked nicely. Constructive is direct but caring, based on Radical Candor principles.

What is Radical Candor?

A management philosophy that combines caring personally with challenging directly. Candid's constructive tone is based on it.

What does .candid/config.json control?

Tone, focus, file exclusions, the ship pipeline (install/build/test/auto-merge/post-merge hook), fast-ship toggles, and Linear integration. See the ship-config reference.

Get started in 5 minutes

# From a terminal
npx skills add https://github.com/ron-myers/candid

# start claude (pass any args you normally would)
claude

# init your project
/candid-init

# Run your first review
/candid-review
Read the Documentation →