codex-claude-loop_skill

Overview

This skill orchestrates a dual-AI engineering loop where Claude Code plans and implements while Codex validates and reviews, creating continuous feedback to improve code quality. It enforces plan validation, iterative implementation, and cross-review to catch logic, security, and architecture issues early. The loop preserves context and session state so reviews and fixes remain consistent.

How this skill works

Claude produces a structured implementation plan, breaking tasks into steps and documenting assumptions. The plan is sent to Codex for validation to surface logic errors, missing edge cases, architecture flaws, and security concerns. If Codex reports problems, Claude refines the plan and repeats validation; once validated, Claude implements changes and sends the implementation back to Codex for code review. This loop continues—apply fixes, re-validate, and resume sessions—until quality standards are met.

When to use it

• When you want an automated peer-review loop between two specialized AIs
• For complex features that benefit from architecture-level validation before coding
• When regulatory, security, or correctness requirements demand multiple-review checkpoints
• When you need continual re-validation after iterative changes
• For teams that want documented handoffs and provenance of who changed what

Best practices

• Always validate the plan with Codex before implementing any code
• Never skip the cross-review step after changes are made
• Document assumptions, decisions, and who performed each action for traceability
• Use resumed validation sessions to preserve model, reasoning effort, and sandbox settings
• Confirm with the user before major architectural or multi-file breaking changes

Example use cases

• Building a new microservice: Claude drafts architecture and implementation steps, Codex validates design and edge cases before code is written
• Security-sensitive fixes: Codex prioritizes security concerns; Claude implements fixes and documents decisions
• Refactoring a legacy module: Claude creates a phased refactor plan; Codex checks for regressions and performance regressors
• Continuous delivery pipelines: integrate the loop to gate merges with Codex validation and Claude fixes
• Prototype validation: rapidly iterate features with automated plan review and follow-up code reviews