---

name: codex-claude-loop description: Orchestrates a dual-AI engineering loop where Claude Code plans and implements, while Codex validates and reviews, with continuous feedback for optimal code quality

Codex-Claude Engineering Loop Skill

Core Workflow Philosophy

This skill implements a balanced engineering loop:

• Claude Code: Architecture, planning, and execution
• Codex: Validation and code review
• Continuous Review: Each AI reviews the other's work
• Context Handoff: Always continue with whoever last cleaned up

Prerequisites

Required:

• Codex CLI installed and authenticated (codex login)

Optional (for code generation):

• claude-codex-orchestrator MCP server
• Provides generate_code tool for complex algorithms
• Without it: Claude implements all code directly

Two Codex methods:

1. CLI (codex exec): Plan validation, code review (read-only sandbox)
2. MCP tool (generate_code): Code generation during implementation (Phase 4 only)

Phase 1: Planning with Claude Code

1. Start by creating a detailed plan for the task
2. Break down the implementation into clear steps
3. Document assumptions and potential issues
4. Output the plan in a structured format

Phase 2: Plan Validation with Codex

1. Ask user (via AskUserQuestion):
   • Model: gpt-5.1 or gpt-5-codex
   • Reasoning effort: low, medium, or high
2. Send the plan to Codex for validation:

Copy   echo "Review this implementation plan and identify any issues:
   [Claude's plan here]
   
   Check for:
   - Logic errors
   - Missing edge cases
   - Architecture flaws
   - Security concerns" | codex exec -m  --config model_reasoning_effort="" --sandbox read-only

1. Capture Codex's feedback

Phase 3: Feedback Loop

If Codex finds issues:

1. Summarize Codex's concerns to the user
2. Refine the plan based on feedback
3. Ask user (via AskUserQuestion): "Should I revise the plan and re-validate, or proceed with fixes?"
4. Repeat Phase 2 if needed

Phase 4: Execution

Once the plan is validated:

1. Claude implements the code using available tools (Edit, Write, Read, etc.)

2. For complex algorithms or critical logic, consider using generate_code tool:

   Use when encountering:

   • Security-critical: Cryptographic operations, authentication flows, signature verification
   • Performance-critical: Complex algorithms, data processing, optimization-heavy code
   • Math-heavy: Statistical calculations, encoding/decoding, mathematical transformations
   • High complexity: >50 lines of logic, deeply nested conditions, many edge cases

   Examples:

   • PKCE challenge generation for OAuth
   • AES encryption/decryption implementation
   • JWT signature verification
   • Complex regex patterns for validation
   • Sorting algorithms with multiple edge cases

3. When using generate_code:

   • Provide clear context about the algorithm needed
   • Specify language and any constraints
   • Integrate generated code naturally into project structure
   • Match project types, interfaces, and patterns
   • Maintain consistency with existing code style
   • If tool unavailable: Implement directly, note in documentation
   • If generation fails: Fall back to direct implementation

4. Break down implementation into manageable steps

5. Execute each step carefully with proper error handling

6. Document what was implemented

   • Mention which parts used generate_code if any
   • Example: "Implemented OAuth. PKCE algorithm generated by Codex."

Phase 5: Cross-Review After Changes

After every change:

1. Send Claude's implementation to Codex for review:
   • Bug detection
   • Performance issues
   • Best practices validation
   • Security vulnerabilities
2. Claude analyzes Codex's feedback and decides:
   • Apply fixes immediately if issues are critical
   • Discuss with user if architectural changes needed
   • Document decisions made

Phase 6: Iterative Improvement

1. After Codex review, Claude applies necessary fixes
2. For significant changes, send back to Codex for re-validation
3. Continue the loop until code quality standards are met
4. Use codex exec resume --last to continue validation sessions:

Copy   echo "Review the updated implementation" | codex exec resume --last

Note: Resume inherits all settings (model, reasoning, sandbox) from original session

Recovery When Issues Are Found

When Codex identifies problems:

1. Claude analyzes the root cause
2. Implements fixes using available tools
3. Sends updated code back to Codex for verification
4. Repeats until validation passes

When implementation errors occur:

1. Claude reviews the error/issue
2. Adjusts implementation strategy
3. Re-validates with Codex before proceeding

Best Practices

• Always validate plans before execution
• Never skip cross-review after changes
• Maintain clear handoff between AIs
• Document who did what for context
• Use resume to preserve session state

Command Reference

Error Handling

1. Stop on non-zero exit codes from Codex
2. Summarize Codex feedback and ask for direction via AskUserQuestion
3. Before implementing changes, confirm approach with user if:
   • Significant architectural changes needed
   • Multiple files will be affected
   • Breaking changes are required
4. When Codex warnings appear, Claude evaluates severity and decides next steps

The Perfect Loop

CopyPlan (Claude) → Validate Plan (Codex) → Feedback →
Implement (Claude) → Review Code (Codex) →
Fix Issues (Claude) → Re-validate (Codex) → Repeat until perfect

This creates a self-correcting, high-quality engineering system where:

• Claude handles all code implementation and modifications
• Codex provides validation, review, and quality assurance