Skip to content
Skills Library
Programming · Building & coding

full

/full

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.

Licence
MIT
Last repository change
22.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
5
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 22.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

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.

Arguments

/full <feature description> [--codex]
Original author 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.

How it works

  1. Usage
  2. Flags
  3. Workflow Overview
  4. State Machine
  5. Cycle Limits
  6. Integration
  7. Iron Laws
  8. References
Original SKILL.md headings · 155 lines, 939 words
SKILL.md preview
---
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
Files in this package (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

Versions

RepositoryScoreLicence
This page · oliver-kriska/claude-elixir-phoenix100MIT
alienfast/claude100MIT
whchoi98/harness-eval100MIT

Database snapshot: 13.11.2026 · package version 0ec869af25bd (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

  • 100phx-full
    Run portable end-to-end lifecycle with gates. Use for full features; use $elixir-phoenix:phx-work for an existing plan.
  • 100phoenix-contexts
    Phoenix context design — creating/splitting contexts, Scope (1.8+); Use when editing contexts, routers, or designing…
  • 100feature-cycle
    End-to-end orchestrator chaining spec → plan → implement → verify → review → ship from a local spec — the whole CLAUDE.md lifecycle as one command. Use to drive a complete feature from a ready spec. To validate what to build first use /office-hours.
  • 100deliver-feature
    Deliver a ticket from start to end with the agents: brief, plan, build, verification, reviews, fixes and docs. It stops before shipping. Run only when the user asks.
  • 90may
    Use when the user mentions MAY, requests an engineering team workflow, or asks for coordinated planning, implementation, review, and acceptance checks.
  • 100implement-feature
    End-to-end feature implementation workflow. Use when the user says "implement", "build feature", "work on task", "start implementation", or any feature development work. Covers plan review, test writing, implementation, verification, and delivery.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.