full
/full
Dostarcza duży, przekrojowy feature lub cały system w Phoenix przez planowanie, implementację, weryfikację i przegląd, gdy kilka powiązanych przepływów musi powstać razem.
- Autor
- oliver-kriska ↗
- Repozytorium
- claude-elixir-phoenix ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 22.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 5
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 22.10.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Dostarcza duży, przekrojowy feature lub cały system w Phoenix przez planowanie, implementację, weryfikację i przegląd, gdy kilka powiązanych przepływów musi powstać razem.
Argumenty
/full <feature description> [--codex]
Oryginalny opis (EN)
Deliver a large, cross-domain Phoenix feature or complete end-to-end system through planning, implementation, verification, and review. Use when several coordinated workflows or contexts must ship together. NOT for an existing plan; use /phx:work.
Jak działa
- Usage
- Flags
- Workflow Overview
- State Machine
- Cycle Limits
- Integration
- Iron Laws
- References
Podgląd SKILL.md
---
name: full
description: "Deliver a large, cross-domain Phoenix feature or complete end-to-end system through planning, implementation, verification, and review. Use when several coordinated workflows or contexts must ship together. NOT for an existing plan; use /phx:work."
effort: high
argument-hint: <feature description> [--codex]
---
# Full Phoenix Feature Development
Execute complete Elixir/Phoenix feature development autonomously: research patterns,
plan with specialist agents, implement with verification, Elixir code review.
Cycles back automatically if review finds issues.
## Usage
```
/phx:full Add user authentication with magic links
/phx:full Real-time notification system with Phoenix PubSub
/phx:full Background job processing for email campaigns --max-cycles 5
/phx:full Add magic-link auth --codex
```
**Wrong input guard**: if the argument is a path to an existing plan file
(`.claude/plans/*/plan.md`), do NOT re-plan it. Say so and run `/phx:work {path}`
instead — the plan phase already happened.
## Flags
- **`--codex`** — Codex CLI joins the review panel on **every** review
cycle, matching `/phx:review --codex`.
- **Requires** the `codex` CLI. A missing CLI degrades to a SKIPPED note —
the cycle never fails.
- **Consensus** findings (flagged by a Claude agent **and** codex) are
marked HIGH CONFIDENCE.
## Workflow Overview
```
┌──────────────────────────────────────────────────────────────────┐
│ /phx:full {feature} │
├──────────────────────────────────────────────────────────────────┤
│ │
│ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ │
│ │Discover│→ │ Plan │→ │ Work │→ │ Verify │→ │ Review │→ │Compound│→Done│
│ │ Assess │ │[Pn-Tm] │ │Execute │ │ Full │ │4 Agents│ │Capture │ │
│ │ Decide │ │ Phases │ │ Tasks │ │ Loop │ │Parallel│ │ Solve │ │
│ └───┬────┘ └────────┘ └────────┘ └───┬────┘ └────────┘ └────────┘ │
│ │ ↑ │ ↑ │ │
│ ├── "just do it" ────────────┤ │ │ │ │
│ ├── "plan it" ──┐ │ ↓ │ │ │
│ │ ↓ │ ┌────────┐│ │ │
│ │ ┌──────────────┐ │ │Fix ││ ┌─────────┐ │ │
│ │ │ PLANNING │ │ │Issues │└─│ Fix │←┘ │
│ │ └──────────────┘ │ └───┬────┘ │ Review │ │
│ │ │ ↓ │ Findings│ │
│ │ ┌────┴─────────┐ └────┬────┘ │
│ │ │ VERIFYING │←──────┘ │
│ └── "research it" ─────┘ (re-verify) │
│ (comprehensive plan) │
│ │
│ On Completion: │
│ Auto-compound: Capture solved problems → .claude/solutions/ │
│ Auto-suggest: /phx:document → /phx:learn-from-fix │
│ │
└──────────────────────────────────────────────────────────────────┘
```
## State Machine
```
STATES: INITIALIZING → DISCOVERING → PLANNING → WORKING →
VERIFYING → REVIEWING → COMPLETED → COMPOUNDING | BLOCKED
```
### Claude Code nesting compatibility
Before delegating this cycle, determine the effective maximum nesting depth:
1. If `CLAUDE_CODE_MAX_SUBAGENT_SPAWN_DEPTH` is a positive integer, use it.
2. Otherwise, inspect `claude --version`: the default is 1 in Claude Code
2.1.217–2.1.218 and 3 in 2.1.219+.
3. If the version cannot be determined, conservatively use 1.
- **Depth 3+** — the full nested topology is available; delegate to
`phx:workflow-orchestrator` as usual.
- **Depth 1–2** — execute the same state machine in this main
session. Read `${CLAUDE_PLUGIN_ROOT}/agents/workflow-orchestrator.md` for the
phase contract, but spawn leaf research/review specialists directly. Do not
spawn `workflow-orchestrator`, `planning-orchestrator`, or
`parallel-reviewer`, because those agents need to delegate again. Context
supervision may still be spawned directly after its input files exist.
The fallback is a topology change only: preserve the same user decisions,
artifacts, verification gates, retry/cycle limits, and review-to-fix loop.
Never tell the user to set an environment variable just to make `/phx:full`
work.
Save state in `.claude/plans/{slug}/progress.md`. If `TaskCreate` is in
your tool list (Sonnet 5+ and Opus 4.8+ omit it unless
`CLAUDE_CODE_ENABLE_TODO_TOOLS=1`; never ToolSearch for it), also create one
task per phase at start, mark `in_progress` on entry and `completed` on exit:
```
TaskCreate({subject: "Discover & assess complexity", activeForm: "Discovering..."})
TaskCreate({subject: "Plan feature", activeForm: "Planning..."})
TaskCreate({subject: "Implement tasks", activeForm: "Working..."})
TaskCreate({subject: "Verify implementation", activeForm: "Verifying..."})
TaskCreate({subject: "Review with specialists", activeForm: "Reviewing..."})
TaskCreate({subject: "Capture solutions", activeForm: "Compounding..."})
```
Set up `blockedBy` dependencies between phases (sequential).
Run COMPOUNDING phase on COMPLETED to capture solved problems in `.claude/solutions/`.
Suggest `/phx:document` for docs and `/phx:learn-from-fix` for quick pattern capture.
## Cycle Limits
| Setting | Default | Description |
|---------|---------|-------------|
| `--max-cycles` | 10 | Max plan→review cycles |
| `--max-retries` | 3 | Max retries per task |
| `--max-blockers` | 5 | Max blockers before stopping |
Stop with INCOMPLETE status when limits exceeded. List remaining work and recommended action.
## Integration
```text
/phx:full = /phx:plan → /phx:work → /phx:verify → /phx:review → (fix → /phx:verify) → /phx:compound
```
Use Ralph Wiggum Loop for fully autonomous execution:
```bash
/ralph-loop:ralph-loop "/phx:full {feature}" --completion-promise "DONE" --max-iterations 50
```
## Iron Laws
1. **NEVER skip verification** — Every task must pass `mix compile --warnings-as-errors` before moving to the next. Run `mix test <affected>` per-phase, full suite only at final gate
2. **Respect cycle limits** — When `--max-cycles` is exhausted, STOP with INCOMPLETE status. Do not continue indefinitely hoping the next fix works
3. **One state transition at a time** — Follow the state machine strictly. Never jump from PLANNING to REVIEWING — each state produces artifacts the next state needs
4. **Discover before deciding** — Always run DISCOVERING phase to assess complexity. Skipping it for "simple" features leads to underplanned implementations
5. **Agent output is findings, not fixes** — Review agents report issues. Only the WORKING state makes code changes
6. **Skip redundant review agents** — In REVIEWING phase: skip
verification-runner (work phase already verified), skip iron-law-judge
if PostToolUse hooks verified all files. For <200 lines changed,
spawn only elixir-reviewer + security-analyzer (if auth files)
7. **Write text where the user needs it** — In autonomous mode your text is
how the user follows the cycle. Write it at phase transitions (one line:
state, cycle N of max, what's next), for decisions that need a reason,
and for errors and blockers. Routine tool calls need no preamble.
## References
- `${CLAUDE_SKILL_DIR}/references/execution-steps.md` — Detailed step-by-step execution
- `${CLAUDE_SKILL_DIR}/references/example-run.md` — Example full cycle run
- `${CLAUDE_SKILL_DIR}/references/safety-recovery.md` — Safety rails, resume, rollback
- `${CLAUDE_SKILL_DIR}/references/cycle-patterns.md` — Advanced cycling strategies
Pliki w paczce (5)
- SKILL.md 9 KB
- references/cycle-patterns.md 4 KB
- references/example-run.md 2 KB
- references/execution-steps.md 4 KB
- references/safety-recovery.md 2 KB
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · oliver-kriska/claude-elixir-phoenix | 100 | MIT |
| alienfast/claude | 100 | MIT |
| whchoi98/harness-eval | 100 | MIT |
Migawka bazy z 13.11.2026 · wersja paczki 0ec869af25bd (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
- 100phx-full
Prowadzi pełny cykl pracy nad funkcją Elixir i Phoenix z bramkami kontrolnymi, od pomysłu po gotowy kod. - 100phoenix-contexts
Pomaga projektować konteksty Phoenix, czyli ich tworzenie, dzielenie i Scope, przy edycji kontekstów i routerów. - 100feature-cycle
Prowadzi funkcję od gotowej specyfikacji przez plan, implementację, weryfikację, przegląd i wydanie jednym poleceniem, w cyklu życia opisanym w CLAUDE.md. - 100deliver-feature
Prowadzi zgłoszenie od briefu przez plan, budowę, weryfikację i poprawki do dokumentacji, zatrzymując się przed wdrożeniem. - 90may
Prowadzi zespół inżynierski przez planowanie, implementację, przegląd i akceptację zmian w jednym przepływie pracy. - 100implement-feature
Prowadzi pełny workflow implementacji funkcji: przegląd planu, pisanie testów, kod, weryfikacja i dostarczenie.