phx-codex-loop
/phx-codex-loop
Fix Elixir/Phoenix code until Codex CLI review comes back clean — bounded review, fix, verify loop before opening a PR. Use when codex is installed and you want an external cross-model critic on your changes before pushing.
- Author
- oliver-kriska ↗
- Repository
- claude-elixir-phoenix ↗
- Licence
- MIT
- Last repository change
- 22.10.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 22.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
What it does and when to use it
Fix Elixir/Phoenix code until Codex CLI review comes back clean — bounded review, fix, verify loop before opening a PR. Use when codex is installed and you want an external cross-model critic on your changes before pushing.
Original author description
Fix Elixir/Phoenix code until Codex CLI review comes back clean — bounded review, fix, verify loop before opening a PR. Use when codex is installed and you want an external cross-model critic on your changes before pushing.
How it works
- Usage
- Iron Laws
- Workflow
- Integration
- References
SKILL.md preview
---
name: phx-codex-loop
description: Fix Elixir/Phoenix code until Codex CLI review comes back clean — bounded
review, fix, verify loop before opening a PR. Use when codex is installed and you
want an external cross-model critic on your changes before pushing.
---
# Codex Loop (fix until clean)
Critic→Refiner loop with the Codex CLI as external critic: review → fix
approved findings → verify → re-review, until codex is clean or rounds run
out. Codex reviews; Claude fixes. Complements `phx-review` (Claude panel)
— run either or both before a PR.
## Usage
```
phx-codex-loop # diff vs default branch, interactive
phx-codex-loop --uncommitted # staged + unstaged + untracked
phx-codex-loop --base develop # explicit base branch
phx-codex-loop --auto # auto-approve P0/P1/P2, skip P3
phx-codex-loop --max-rounds 2 # default 3
```
## Iron Laws
1. **BOUNDED rounds — never exceed --max-rounds (default 3)** — each round
costs codex quota; report remaining findings instead of looping on
2. **Verify BEFORE re-review** — `mix compile --warnings-as-errors` + tests
must pass before burning a codex round on broken code
3. **NEVER commit or push** — leave git to the user
4. **Codex findings get Iron Law scrutiny** — decline suggestions that
violate an Iron Law, with explanation in the round report
5. **Skipped findings are reported, never dropped** — every finding ends as
fixed, declined (with reason), or deferred-by-user
6. **Missing CLI stops the skill with an install hint** — suggest
`phx-review` as the codex-free alternative; never crash
## Workflow
### Step 1: Preflight
Run `command -v codex`. If missing: STOP.
Show the install hint (`brew install codex` or `npm i -g @openai/codex`,
then `codex login`; `codex doctor` to diagnose) and suggest `phx-review`.
Then two cheap checks that save review rounds:
- **Dirty tree** (`git status --short`, only when using `--base`): codex
inspects working-tree state too and WILL flag local dirt (stray edits,
dirty submodules) as findings. Surface the dirt and ask: clean/stash
first, or proceed knowing round 1 may spend findings on it.
- **Missing rubric**: if `AGENTS.md` has no `## Review guidelines`
section, note once that `phx-init` installs the Elixir rubric that
steers codex priorities — then proceed (it works without, on defaults).
### Step 2: Detect Diff Mode
- **Flag passed** (`--base`/`--uncommitted`) → use as given
- **Commits ahead of the default branch** → `--base {default}`
- **No commits yet** → `--uncommitted`
### Step 3: Review Round (max `--max-rounds`, default 3)
1. **Review** — ONE foreground Bash call, explicit `timeout: 600000`
(large diffs run 10+ min). On timeout with the process alive: ONE
`until [ -f {out} ]; do sleep 5; done` wait — never poll-spam or
`pkill` a running review (quota is spent either way). ALWAYS silence
the streams — only the `-o` file matters (10k+ lines otherwise):
```bash
codex exec review --base {branch} --ephemeral \
-o /tmp/codex-round-{n}.md > /tmp/codex-round-{n}.log 2>&1
```
NEVER pass custom instructions with a diff-mode flag — the CLI rejects
the combination; the rubric comes from AGENTS.md `## Review guidelines`
(`phx-init`). Parse the output file, NOT the exit code (0 even with
findings). Recipes: `references/codex-cli.md`.
**Retired model** (exit 1, no `-o` file, log: `model is not supported`
/ `Model not found`): resolve the account default — `MODEL=$(codex debug
models | jq -r '.models | map(select(.visibility == "list")) |
sort_by(.priority) | .[0].slug')` — retry once with `-m "$MODEL"
-c review_model="$MODEL"` (both: a pinned `review_model` beats `-m`),
reuse it every round, never hardcode a slug. Tell the user once to set
`model`/`review_model = "$MODEL"` in `~/.codex/config.toml`.
2. **Clean check** — parse the output file; no `- [P{n}]` bullets means
CLEAN → go to Step 5.
### Step 4: Triage, Fix, Verify
1. **Triage** — emit the findings table
(`# | P | file:line | title | proposed action`) as **visible
response text BEFORE any `AskUserQuestion` call** — a table composed
only in thinking never renders. Then ask approve-or-skip per finding
(`AskUserQuestion`). With `--auto`: approve P0/P1/P2, skip P3 (list
skipped in the round report).
2. **Fix** — apply approved fixes with user-visible diffs. Check each
against Iron Laws first (Law 4).
3. **Verify** — scoped, before the next round:
```bash
mix format {changed_files} && \
mix compile --warnings-as-errors && mix test {affected_tests}
```
If verification fails 3 times, STOP with a BLOCKER report — do not
burn another codex round on broken code.
4. Next round (n+1) — back to Step 3.
### Step 5: Final Report
```markdown
## Codex Loop Report — {CLEAN | MAX ROUNDS REACHED | BLOCKED}
Rounds: {n}/{max} | Fixed: {n} | Declined (Iron Law): {n} | Deferred: {n}
{per-round: findings → outcome}
{remaining findings if not CLEAN}
```
On CLEAN: suggest `phx-compound` for non-obvious fixes, then commit/PR.
On MAX ROUNDS: list remaining findings; offer `phx-plan` to convert them
into a follow-up plan.
## Integration
```text
implement → phx-codex-loop (YOU ARE HERE) → clean → commit/PR → phx-watch-pr --codex
↑ or arrive from phx-review --codex verdict REQUIRES CHANGES
```
## References
- `references/codex-cli.md` — invocation recipes, parse
patterns, verified gotchas (CLI 0.142.5; model fallback 0.162.1)
Files in this package (2)
- SKILL.md 5 KB
- references/codex-cli.md 6 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · oliver-kriska/claude-elixir-phoenix | 100 | MIT |
| oliver-kriska/claude-elixir-phoenix | 100 | MIT |
| oliver-kriska/claude-elixir-phoenix | 100 | MIT |
| oliver-kriska/claude-elixir-phoenix | 100 | MIT |
Database snapshot: 13.11.2026 · package version b9153520e399 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100codex-loop
Fix Elixir/Phoenix code until Codex CLI review comes back clean — bounded review, fix, verify loop before opening a PR. Use when codex is installed and you want an external cross-model critic on your changes before pushing. - 100phx-help
Recommend the right $elixir-phoenix:phx-* workflow. Use when choosing a plugin skill, not for Codex /help. - 95codex-review
Run OpenAI Codex CLI to review code changes and iterate until clean. Use this skill whenever the user says "codex review", "have codex check", "run codex on that", "codex loop", "review with codex", or asks you to get a second opinion on your commit from Codex/OpenAI. Also use… - 100review-fix-swarm
Run a bounded post-implementation multi-agent review, bug-fix, behavior-preserving simplification, and re-review loop. Use when the user requests a Codex-only swarm or optional Codex/Pi hybrid test on a specified branch/PR. Do not use for feature implementation or automated releases. - 100code-review-loop
Push local work as a GitHub PR against a user-specified base branch and run a recurring review/fix loop combining @codex review with a separate broader review of smaller bugs, edge cases, and meaningful missing tests. Validate and push fixes, then repeat until both reviews are… - 100codex-review
Run Codex code review with Claude's independent double-check. Use when asked \"codex review\", \"review my code with codex\", or wants Codex to review code changes. For adversarial review use /codex-adversarial.