codex-claude-cursor-loop

This skill implements a 3-way sequential validation engineering loop:

• Claude Code: Architecture and planning, final review
• Codex: Plan validation (logic/security), code review (bugs/performance)
• Cursor Agent: Code implementation and execution
• Sequential Validation: Claude plans → Codex validates → Cursor implements → Codex reviews → Claude final check → repeat

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

1. Ask user (via AskUserQuestion):

- Model: gpt-5 or gpt-5-codex

- Reasoning effort: low, medium, or high

1. Send the plan to Codex for validation:

```bash

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 and summarize to user

If Codex finds issues in the plan:

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 implementation?"
4. Repeat Phase 2 if needed until plan is solid

Once the plan is validated by Codex:

Session Management

1. Ask user (via AskUserQuestion): "Do you want to start a new Cursor session or resume an existing one?"

- New session: Start fresh

- Resume session: Continue previous work

1. If resuming:

```bash

# Note: cursor-agent ls requires interactive mode and may not work in --print mode

# Alternative: Ask user for chat ID from their previous session

# Or use: cursor-agent resume (resumes latest session without ID)

# Store session ID for subsequent calls

```

1. Ask user (via AskUserQuestion): Which Cursor model to use

- Available models: sonnet-4, sonnet-4-thinking, gpt-5, gpt-4o, composer-1

- Recommended: sonnet-4 for balanced performance, sonnet-4-thinking for complex reasoning

Implementation

1. Send the validated plan to Cursor Agent:

For new session:

```bash

cursor-agent --model "" -p --force --output-format json --approve-mcps "Implement this plan:

[Validated plan here]

Please implement the code following these specifications exactly."

```

For resumed session (with chat ID):

```bash

cursor-agent --resume --model "" -p --force --output-format json "Continue implementation:

[Validated plan here]"

```

For resumed session (latest chat):

```bash

cursor-agent resume --model "" -p --force --output-format json "Continue implementation:

[Validated plan here]"

```

Useful options:

• --output-format json: Structured output for parsing (recommended for automation)
• --approve-mcps: Auto-approve MCP servers (useful in headless mode)
• --stream-partial-output: Real-time progress monitoring (use with --output-format stream-json)
• --browser: Enable browser automation if needed

1. IMPORTANT: Store the session ID from the output for all subsequent Cursor calls
2. Capture what was implemented and which files were modified

After Cursor implements:

1. Send Cursor's implementation to Codex for code review:

```bash

echo "Review this implementation for:

- Bugs and logic errors

- Performance issues

- Security vulnerabilities

- Best practices violations

- Code quality concerns

Files modified: [list of files]

Implementation summary: [what Cursor did]" | codex exec --sandbox read-only

```

1. Capture Codex's code review feedback
2. Summarize findings to user

After Codex code review:

1. Claude reads the implemented code using Read tool
2. Claude analyzes both:

- Codex's review findings

- The actual implementation

1. Claude provides final assessment:

- Verify if it matches the original plan

- Confirm Codex's findings are valid

- Identify any additional concerns

- Make final architectural decisions

1. Summarize overall quality and readiness

If issues are found (by Codex or Claude):

1. Claude creates a detailed fix plan based on:

- Codex's code review findings

- Claude's final review insights

1. Send the fix plan to Cursor Agent using the same session:

```bash

# IMPORTANT: Use --resume with the stored session ID

cursor-agent --resume --model "" -p --force --output-format json "Fix these issues:

[Detailed fix plan]

Issues from Codex: [list]

Issues from Claude: [list]"

# Or resume latest session:

cursor-agent resume --model "" -p --force --output-format json "Fix these issues..."

```

1. After Cursor fixes, repeat from Phase 5 (Codex code review)
2. Continue the loop until all validations pass
3. Note:

- Use same Codex model for consistency

- Always use the same Cursor session ID to maintain context

- Session maintains full history of changes

When Codex finds plan issues (Phase 2):

1. Claude analyzes Codex's concerns
2. Refines the plan addressing all issues
3. Re-submits to Codex for validation
4. Repeats until Codex approves

When Codex finds code issues (Phase 5):

1. Claude reviews Codex's findings
2. Creates detailed fix plan
3. Sends to Cursor for fixes
4. After Cursor fixes, back to Codex review
5. Repeats until Codex approves

When Claude finds issues (Phase 6):

1. Claude creates comprehensive fix plan
2. Sends to Cursor for implementation
3. After fixes, Codex reviews again
4. Claude does final check
5. Repeats until Claude approves

• Always validate plans with Codex before implementation
• Never skip Codex code review after Cursor implements
• Never skip Claude's final review for architectural oversight
• Maintain clear handoff between all three AIs
• Document who did what for context
• Use same models throughout (same Codex model, same Cursor model)
• Session Management:

- Always use --resume with same session ID for iterative fixes

- Store session ID at the start and reuse throughout

- Use cursor-agent resume to resume latest session (no ID needed)

- Note: cursor-agent ls requires interactive mode (may not work in scripts)

- Only start new session when beginning completely new feature

• Output Format:

- Use --output-format json for structured, parseable output

- Use --stream-partial-output with stream-json for real-time progress

- Helps with error detection and progress monitoring

| Phase | Who | Command Pattern | Purpose |

|-------|-----|----------------|---------|

| 1. Plan | Claude | TodoWrite, Read, analysis tools | Claude creates detailed plan |

| 2. Validate plan | Codex | echo "plan" \| codex exec -m --config model_reasoning_effort="" --sandbox read-only | Codex validates logic/security |

| 3. Refine | Claude | Analyze Codex feedback, update plan | Claude fixes plan issues |

| 4. Session setup | Claude + User | Ask new/resume, ask for chat ID if resuming | Setup or resume Cursor session |

| 5. Implement | Cursor | New: cursor-agent --model "" -p --force --output-format json --approve-mcps "prompt"
Resume: cursor-agent --resume --model "" -p --force --output-format json "prompt"
Latest: cursor-agent resume -p --force --output-format json "prompt" | Cursor implements validated plan |

| 6. Review code | Codex | echo "review" \| codex exec --sandbox read-only | Codex reviews for bugs/performance |

| 7. Final review | Claude | Read tool, analysis | Claude final architectural check |

| 8. Fix plan | Claude | Create detailed fix plan | Claude plans fixes from all feedback |

| 9. Apply fixes | Cursor | cursor-agent --resume --model "" -p --force --output-format json "fixes" OR cursor-agent resume -p --force --output-format json "fixes" | Cursor implements fixes in same session |

| 10. Re-review | Codex + Claude | Repeat phases 6-7 | Validate fixes until perfect |

Available Command-Line Options

• --model : Choose AI model (sonnet-4, sonnet-4-thinking, gpt-5, gpt-4o, composer-1)
• -p, --print: Print mode for scripts (headless, non-interactive)
• -f, --force: Auto-approve commands unless explicitly denied
• --output-format : Output format (text | json | stream-json)
• --stream-partial-output: Stream partial output as deltas (with stream-json)
• --approve-mcps: Auto-approve all MCP servers (headless mode only)
• --browser: Enable browser automation support
• --resume [chatId]: Resume specific chat or latest if no ID provided

Session Management Commands

• cursor-agent create-chat: Create new empty chat and return ID
• cursor-agent resume: Resume latest chat session (no ID needed)
• cursor-agent --resume : Resume specific chat by ID
• cursor-agent ls: List sessions (requires interactive mode, not for scripts)

Model Recommendations

• sonnet-4: Best balance of speed and quality (recommended default)
• sonnet-4-thinking: Deep reasoning for complex architectural decisions
• gpt-5: Latest OpenAI model with strong coding capabilities
• gpt-4o: Fast responses, good for iterative fixes
• composer-1: Cursor's native composer model

Output Format Strategies

1. For automation/scripts: --output-format json

- Structured, parseable output

- Easy error detection

- Better for Claude to process results

1. For real-time monitoring: --output-format stream-json --stream-partial-output

- See progress as it happens

- Detect issues early

- Cancel if going wrong direction

1. For human review: --output-format text (default)

- Readable format

- Good for debugging

1. Monitor Cursor Agent output for errors (easier with JSON output)
2. Summarize Cursor's implementation results and Claude's review
3. Ask for user direction via AskUserQuestion if:

- Significant architectural changes needed

- Multiple files will be affected

- Breaking changes are required

1. When issues appear, Claude creates a detailed fix plan before sending to Cursor
2. JSON parsing: When using --output-format json, parse the output to extract:

- Files modified

- Commands executed

- Error messages

- Session ID for resume

```

1. Plan (Claude)

↓

1. Validate Plan (Codex) → if issues → refine plan → repeat

↓

1. Implement (Cursor)

↓

1. Code Review (Codex) → captures bugs/performance issues

↓

1. Final Review (Claude) → architectural check

↓

1. Issues found? → Fix Plan (Claude) → Implement Fixes (Cursor) → back to step 4

↓

1. All passed? → Done! ✅

```

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

• Claude: All planning, architecture, and final oversight
• Codex: All validation (plan logic + code quality)
• Cursor Agent: All implementation and coding