codex-iterative-solver

Help users solve complex coding problems by:

1. Gathering detailed context about the problem and codebase
2. Creating structured prompts for Codex CLI analysis
3. Running Codex in non-interactive mode
4. Parsing and presenting Codex's critical feedback
5. Refining plans based on feedback
6. Iterating until a robust solution is found

Use this skill when the user needs to:

• Analyze a complex codebase with multiple possible approaches
• Get external validation on implementation plans
• Iterate on solutions based on expert feedback
• Solve problems that benefit from multiple perspectives
• Validate experimental designs or data processing pipelines

Ask the user these questions:

1. What problem are you trying to solve?

- Clear statement of the goal

- Any constraints or requirements

1. What are the relevant code locations?

- Main files involved

- Data locations and formats

- Dependencies or related components

1. Do you have proposed approaches?

- If yes: What are they and their pros/cons?

- If no: Should I analyze and propose options?

1. What specific concerns do you have?

- Performance optimization?

- Correctness/accuracy?

- Maintainability?

- Scalability?

Generate a structured prompt file with this template:

```markdown

# Problem Description

[Clear, concise statement of the problem]

Locations:

• File1: /path/to/file (purpose and role)
• File2: /path/to/file (purpose and role)
• Data: /path/to/data (format and structure)

Current Situation:

[What currently exists, what works, what doesn't]

Approach 1: [Name]

Concept: [Brief description]

Pros:

• [Advantage 1]
• [Advantage 2]

Cons:

• [Limitation 1]
• [Limitation 2]

Approach 2: [Name]

[Same structure as Approach 1]

Please provide critical feedback on:

1. Fatal Flaws: Are there logical errors or critical bugs in these approaches?
2. Missing Considerations: What important factors did I overlook?
3. Risk Assessment: What could go wrong? What are the failure modes?
4. Better Alternatives: Is there a superior approach I haven't considered?
5. Recommendation: Which approach would you choose and why?

```

Save this to: /tmp/codex_iteration_N_prompt.txt

Execute Codex in the working directory:

```bash

cd [working_directory]

codex exec \

-C [working_directory] \

--json \

-o /tmp/codex_iteration_N_output.txt \

"$(cat /tmp/codex_iteration_N_prompt.txt)" \

2>&1 | tee /tmp/codex_iteration_N_log.txt

```

Monitor progress using the BashOutput tool for the background process.

Read /tmp/codex_iteration_N_output.txt and extract:

1. Critical Issues - Problems that must be fixed
2. Missing Considerations - Overlooked factors
3. Risk Assessments - Potential failure modes
4. Alternative Approaches - Codex's suggestions
5. Final Recommendation - What Codex recommends and why

⚠️ Codex도 LLM이므로 hallucination이 발생할 수 있다. 모든 응답을 검증해야 한다.

Codex의 피드백을 그대로 신뢰하지 말고, 다음 단계로 검증:

4.5.1: 검증이 필요한 Codex 응답 유형

| Codex 응답 유형 | 검증 방법 | 도구 |

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

| Critical Issues | 해당 코드에서 실제로 문제인지 확인 | Read tool |

| Missing API/함수 | 해당 API가 실제로 존재하는지 확인 | WebSearch, Grep |

| Alternative Approaches | 제안된 라이브러리/패턴이 실제로 존재하는지 확인 | WebSearch |

| Performance Claims | 성능 주장에 대한 근거 확인 | WebSearch (벤치마크) |

| Best Practices | 해당 분야의 실제 best practice인지 확인 | WebSearch |

4.5.2: 검증 프로세스

```

Codex 응답의 각 항목에 대해:

│

├─ [Critical Issue 주장]

│ → 해당 코드 파일을 Read로 직접 확인

│ → 실제로 문제가 있는지 검증

│ → 없는 문제를 지적했다면 무시

│

├─ [라이브러리/API 제안]

│ → WebSearch로 해당 라이브러리 존재 확인

│ → 프로젝트 requirements.txt와 호환성 확인

│ → 존재하지 않는 라이브러리면 무시

│

├─ [코드 패턴 제안]

│ → 프로젝트 기존 코드에서 유사 패턴 확인

│ → 프로젝트 컨벤션과 맞는지 확인

│

└─ [성능/보안 주장]

→ WebSearch로 해당 주장의 근거 확인

→ 검증 불가능한 주장은 "검증 필요" 표시

```

4.5.3: 검증 결과 기록

```

✓ Verified Codex Feedback:

• "SQL injection 취약점" ✓ (user_input이 직접 쿼리에 사용됨 확인)
• "asyncio 사용 권장" ✓ (Python 공식 문서에서 I/O bound 작업에 권장)

✗ REJECTED (Hallucination):

• "use torch.quantum module" ✗ (WebSearch: 해당 모듈 존재하지 않음)
• "line 45 has memory leak" ✗ (해당 라인에 메모리 누수 없음)

⚠️ Needs Manual Verification:

• "이 알고리즘은 O(n²) 복잡도" → 실제 분석 필요

```

4.5.4: 절대 금지 사항

❌ 절대 하지 말 것:

• Codex 응답을 검증 없이 그대로 사용자에게 전달
• 존재하지 않는 라이브러리 설치 제안
• 확인하지 않은 Critical Issue를 실제 문제로 보고
• Codex의 코드 제안을 검증 없이 적용

✅ 반드시 할 것:

• 모든 Critical Issue는 실제 코드에서 확인
• 새 라이브러리 제안은 WebSearch로 존재 확인
• 검증된 피드백만 사용자에게 보고
• 불확실한 항목은 "검증 필요" 명시

Based on Codex's feedback:

1. Fix Critical Issues - Address any fatal flaws immediately
2. Incorporate Missing Factors - Add overlooked considerations
3. Adjust Estimates - Update time/resource estimates based on new info
4. Document Changes - Clearly note what changed and why

Show the user:

• Key findings from Codex (2-3 sentence summary)
• Updated plan incorporating feedback
• Next steps: Iterate Again, Proceed with Implementation, or Manual Refinement

If user chooses "Iterate":

• Return to Phase 2 with the refined plan
• Usually converge within 2-3 iterations

If user chooses "Proceed":

• Save final plan to project directory
• Offer to create implementation todos using TodoWrite
• Begin implementation with confidence

Stop iterating when:

• No critical issues remain unaddressed
• All major concerns have been considered
• Implementation path is clear and well-defined
• Known risks are acceptable and documented
• User feels confident to proceed

If Codex fails to respond or errors occur:

• Check logs in /tmp/codex_iteration_N_log.txt for details
• Verify codex CLI is installed and authenticated
• Simplify the prompt if it's too complex
• Try breaking the problem into smaller sub-problems