# Cc Opus Review Loop

> Use for plan reviews and checkpoint reviews during implementation. Pass -Tier to select model preference: high-risk uses Opus 4.6 first, medium uses Sonnet 4.6 first. Supports relaxed cadence after 2 consecutive clean reviews.

- Skill: `xukai-ye/cc-opus-review-loop` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add xukai-ye/cc-opus-review-loop`
- Raw SKILL.md: https://api.skillmd.com/api/skills/xukai-ye/cc-opus-review-loop/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: Xukai-YE (https://skillmd.com/u/xukai-ye)
- Updated: 2026-09-22
- Page: https://skillmd.com/skills/xukai-ye/cc-opus-review-loop

---


# CC Opus Review Loop

This skill adds recurring Claude Code review checkpoints around Codex-led work.

Codex still owns the implementation. Claude Code acts as a reviewer and optimizer at defined checkpoints.

## When to Use

Use this skill whenever Codex has a concrete task plan that should be reviewed, and whenever implementation should be periodically reviewed during execution.

Especially use it if:

- Codex has already formed a complete implementation flow
- the work will span multiple files or milestones
- the blast radius is non-trivial
- a second-model review is valuable before too much code accumulates

You may still use it for smaller work after a few accumulated small changes.

## Tier-Aware Model Preference

| Tier | Model Order |
|------|-------------|
| **high-risk** | `claude-opus-4-6` -> `claude-sonnet-4-6` -> `opus` -> `sonnet` |
| **medium** | `claude-sonnet-4-6` -> `claude-opus-4-6` -> `sonnet` -> `opus` |

Pass `-Tier medium` or `-Tier high-risk` to the invocation script. Default is `high-risk` if omitted.

## Required Review Points

### 1. Plan Review

After Codex finishes the full plan for any non-trivial task, but before major coding begins, run:

```powershell
powershell -NoProfile -ExecutionPolicy Bypass -File "scripts/invoke-cc-opus-review.ps1" `
  -Mode Plan `
  -UserRequest "$ARGUMENTS" `
  -WorkingDirectory "$PWD" `
  -Tier "high-risk"
```

If plan files are already known, pass them explicitly:

```powershell
powershell -NoProfile -ExecutionPolicy Bypass -File "scripts/invoke-cc-opus-review.ps1" `
  -Mode Plan `
  -UserRequest "$ARGUMENTS" `
  -WorkingDirectory "$PWD" `
  -Tier "high-risk" `
  -ContextPaths "task_plan.md","findings.md","IMPLEMENTATION_PLAN.md"
```

### 2. Checkpoint Review

During implementation, review at each meaningful checkpoint.

#### Checkpoint Triggers (risk-first)

Trigger a checkpoint when any of these occur:

1. **Risk increase**: the implementation has moved into a higher-risk area than initially classified.
2. **Milestone boundary**: a logical subtask or milestone is complete.
3. **Direction change**: the approach has shifted from the original plan.
4. **Module or layer boundary crossed**: implementation has entered a new module or architectural layer.
5. *(fallback)* Every 2-4 touched files, roughly every 80-200 changed lines, or after about 3 small edit rounds.

#### Relaxed Cadence Rule

If **two consecutive checkpoint reviews are clean** (no major findings, no direction changes, no new risks), future checkpoints can be relaxed to **milestone boundaries only** until the next:
- risk increase
- direction change
- module or layer boundary crossing

Run:

```powershell
powershell -NoProfile -ExecutionPolicy Bypass -File "scripts/invoke-cc-opus-review.ps1" `
  -Mode Checkpoint `
  -UserRequest "$ARGUMENTS" `
  -WorkingDirectory "$PWD" `
  -Tier "medium" `
  -ConsecutiveCleanCheckpointCount 2 `
  -BatchSummary "Completed batch 1: auth route + session storage + tests" `
  -ContextPaths "src/auth.ts","src/session.ts","tests/auth.test.ts"
```

## How Codex Should Use The Output

For plan review:

- tighten sequencing
- add missing risks and tests
- improve batch boundaries
- correct weak assumptions before coding

For checkpoint review:

- catch regressions early
- check if the batch is cohesive enough
- validate test coverage
- decide whether to keep current direction or adjust before the next batch
- track consecutive clean reviews for relaxed cadence

## Failure Handling

If Claude Code is unavailable, not authenticated, or review fails:

- note the failure briefly
- continue locally in Codex
- do not block the task solely because the review step was unavailable

## Review Cadence Rules

- Do not wait until the very end of a task for the first external review when a real plan already exists.
- Plan review should happen after each meaningful task plan, before major implementation.
- Checkpoint review should happen repeatedly during implementation, not only at completion.
- Small changes should still trigger a review once several minor rounds have accumulated.
- After 2 consecutive clean checkpoint reviews, relax to milestone-only checkpoints.
- Final Codex verification still happens even if Claude Code review already passed.