Przejdź do treści
Biblioteka skilli
Programowanie · Automatyzacja

phx-codex-loop

/phx-codex-loop

Naprawia kod Elixir w pętli z recenzją Codex CLI, aż zewnętrzny krytyk zaakceptuje zmiany.

Licencja
MIT
Ostatnia zmiana repozytorium
22.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 22.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Naprawia kod Elixir w pętli z recenzją Codex CLI, aż zewnętrzny krytyk zaakceptuje zmiany.

Oryginalny opis (EN)

Fix Elixir/Phoenix code until Codex CLI review comes back clean; Use when codex is installed and you want an external…

Jak działa

  1. Usage
  2. Iron Laws
  3. Workflow
  4. Integration
  5. References
Sekcje z nagłówków SKILL.md, w oryginale · 134 linii, 787 słów
Podgląd SKILL.md
---
name: phx-codex-loop
description: Fix Elixir/Phoenix code until Codex CLI review comes back clean; Use
  when codex is installed and you want an external…
---

# 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 `$elixir-phoenix:phx-review` (Claude panel)
— run either or both before a PR.

## Usage

```
$elixir-phoenix:phx-codex-loop                    # diff vs default branch, interactive
$elixir-phoenix:phx-codex-loop --uncommitted      # staged + unstaged + untracked
$elixir-phoenix:phx-codex-loop --base develop     # explicit base branch
$elixir-phoenix:phx-codex-loop --auto             # auto-approve P0/P1/P2, skip P3
$elixir-phoenix: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
   `$elixir-phoenix: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 `$elixir-phoenix: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 `$elixir-phoenix: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`
   (`$elixir-phoenix: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 `$elixir-phoenix:phx-compound` for non-obvious fixes, then commit/PR.
On MAX ROUNDS: list remaining findings; offer `$elixir-phoenix:phx-plan` to convert them
into a follow-up plan.

## Integration

```text
implement → $elixir-phoenix:phx-codex-loop (YOU ARE HERE) → clean → commit/PR → $elixir-phoenix:phx-watch-pr --codex
     ↑ or arrive from $elixir-phoenix: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)
Pliki w paczce (2)
  • SKILL.md 6 KB
  • references/codex-cli.md 6 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · oliver-kriska/claude-elixir-phoenix100MIT
oliver-kriska/claude-elixir-phoenix100MIT
oliver-kriska/claude-elixir-phoenix100MIT
oliver-kriska/claude-elixir-phoenix100MIT

Migawka bazy z 13.11.2026 · wersja paczki 313abd9a9fc5 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100codex-loop
    Naprawia kod Elixir i Phoenix w ograniczonej pętli przegląd, poprawka, weryfikacja, aż przegląd Codex CLI wróci bez uwag, przed otwarciem pull requesta.
  • 100phx-help
    Rekomenduje odpowiedni przepływ pracy phx-* przy wyborze skilla z pluginu Elixir.
  • 95codex-review
    Uruchamia przegląd zmian przez Codex CLI i poprawia je w pętli, aż kod będzie czysty, także jako drugą opinię o commicie.
  • 100gendiff
    Używa API gendiff z elixirstream.dev do pokazania zmian między wersjami generatorów Elixir i Phoenix (phx.new, phx.gen.auth, Nerves, Scenic, Surface, Credo), by aktualizować na podstawie rzeczywistych diffów.
  • 100elixir-expert
    Wspiera pracę z Elixirem, Phoenix, OTP i systemami współbieżnymi.
  • 100codex-review
    Uruchamia jednorazowy przegląd gałęzi w Codex CLI o określonym zakresie jako zewnętrzny adapter review, tylko na wyraźne polecenie.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.