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

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 -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 -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 -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.