Claude Skill

work

Execute Elixir/Phoenix plan tasks with progress tracking. Use after /phx:plan to implement features with mix compile and mix test verification after each step, or --continue to resume interrupted work.

LLM Mart · 0 points · 0 views 0 listing impressions 0 install-command copies
Download oliver-kriska-claude-elixir-phoenix-plugins_elixir-phoenix_skills_work-9767a82.zip · 12 KB

Install

skills CLI npx skills add https://github.com/oliver-kriska/claude-elixir-phoenix/tree/main/plugins/elixir-phoenix/skills/work
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install oliver-kriska-claude-elixir-phoenix@llmmart
Git git clone https://github.com/oliver-kriska/claude-elixir-phoenix.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole oliver-kriska/claude-elixir-phoenix collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Work

Execute tasks from a plan file with checkpoint tracking and verification.

Usage

/phx:work .claude/plans/user-auth/plan.md
/phx:work .claude/plans/user-auth/plan.md --from P2-T3
/phx:work --skip-blockers
/phx:work  # Resumes most recent plan

Arguments

  • <plan-file> -- Path to plan file (optional, auto-detects recent)
  • --from <task-id> -- Resume from specific task (e.g., P2-T3)
  • --skip-blockers -- Continue past blocked tasks
  • --continue -- Resume IN_PROGRESS plan from checkboxes

Iron Laws (NON-NEGOTIABLE)

  1. NEVER auto-proceed to /phx:review or any next workflow phase -- always ask the user what to do next
  2. AUTO-CONTINUE between plan phases -- when Phase N completes, immediately start Phase N+1. Do NOT stop or ask for permission between phases. Only stop at BLOCKERS or when ALL phases are done.
  3. Plan checkboxes ARE the state -- [x] = done, [ ] = pending. No separate JSON state files. Resume by reading the plan.
  4. Verify after EVERY task -- never skip verification
  5. Max 3 retries then BLOCKER -- don't keep retrying forever
  6. Stage specific files -- never use git add -A or git add .
  7. Read scratchpad BEFORE implementing -- scratchpad has dead-ends and decisions that prevent rework. Step 2 is not optional.
  8. Clarify ambiguous tasks -- ask the user rather than guessing when a plan task's intent is unclear

Step 1: Research Decision

Ask the user for plans with >3 tasks:

This plan has remaining tasks across phases.

  1. Start working -- Begin immediately (familiar patterns)
  2. Quick research -- Read source files first (~10 min)
  3. Extensive research -- Web search + docs (~30 min)

Skip for plans with 3 or fewer simple tasks -- just start.

Split warning: Plans with >10 tasks risk 2-3 context compactions. Suggest splitting via /phx:plan if not already.

Step 2: Check Context (MANDATORY)

Read scratchpad and compound docs before writing any code — skipping this causes rework. Read .claude/plans/{slug}/scratchpad.md (short, critical context) for dead-ends and decisions, then Grep .claude/solutions/ for solved patterns. Apply findings: skip dead-ends, follow decisions, reuse patterns. Ask the user when a task's intent is ambiguous — never guess, corrections are expensive.

Step 3: Load, Create Task List, and Resume

Read plan file, count [x] (completed) vs [ ] (remaining). Find first unchecked task by [Pn-Tm] ID.

Create Claude Code tasks only 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). Without it, skip every TaskCreate/TaskUpdate step in this skill — plan checkboxes and progress.md are the state:

For each unchecked `- [ ] [Pn-Tm] Description`:
  TaskCreate({
    subject: "[Pn-Tm] Description",
    description: "Full task details from plan",
    activeForm: "Implementing: Description"
  })

Skip already-checked items ([x]). Set blockedBy between phases (Phase 2 tasks blocked by Phase 1 tasks).

With --from P2-T3: Skip to that specific task.

Stale-plan check: if the plan predates this session (file mtime), spot-check 2-3 files it references before executing — assumptions may have drifted.

See ${CLAUDE_SKILL_DIR}/references/resume-strategies.md for all resume modes.

Step 4: Execute Tasks

Execute each unchecked task (- [ ] [Pn-Tm][agent] Description):

  1. Start task: TaskUpdate({taskId, status: "in_progress"})
  2. Route by [agent] annotation (see ${CLAUDE_SKILL_DIR}/references/execution-guide.md)
  3. Implement the task
  4. Verify: mix format + mix compile --warnings-as-errors (at phase end, also run mix test <affected> — see tiers below)
  5. Complete task: Mark checkbox [x] on pass, append implementation note inline, AND TaskUpdate({taskId, status: "completed"}). Example: - [x] [P1-T3] Add user schema — citext for email, composite index on [user_id, status] This survives context compaction; the plan is re-read on resume.
  6. On failure: retry up to 3 times, then create BLOCKER and write DEAD-END to scratchpad (see error-recovery.md)

Parallel groups: Tasks under ### Parallel: header spawn as background subagents. See ${CLAUDE_SKILL_DIR}/references/execution-guide.md for spawning pattern, prompt template, and checkpoint flow.

Verification tiers (scoped to minimize redundant runs):

  • Per-task: mix compile --warnings-as-errors only (format is checked by PostToolUse hook automatically)
  • Per-phase: mix compile --warnings-as-errors + mix test <affected_files> + mix credo --strict (scope tests: mix test test/path/to_affected_test.exs — NOT full suite)
  • Per-feature (Tidewave): behavioral smoke test via project_eval (create record, fetch, verify -- see execution-guide.md)
  • Final gate: mix test (full suite — run ONCE at the end, not per-phase)

Token efficiency: Write user-facing text for non-obvious decisions and failures; routine verification passes need no commentary. When several checkboxes complete together (parallel groups, resume catch-up), batch them into ONE edit pass — never one Edit call per checkbox. The PostToolUse hook checks formatting but does NOT modify files — run mix format explicitly during verification or before committing.

Step 5: Completion

Summarize results with AskUserQuestion:

Implementation complete! / tasks finished. files modified across phases.

Options: 1. Run review (/phx:review) (Recommended), 2. Get a briefing (/phx:brief — understand what was built), 3. Commit changes (/commit), 4. Continue manually. If any task fixed a non-obvious bug, also mention /phx:compound to capture the solution.

With blockers: list them, offer Replan (/phx:plan), Review first (/phx:review), or Handle myself.

If blockers remain, auto-write HANDOFF to scratchpad:

### [HH:MM] HANDOFF: {plan name}
Status: {done}/{total} tasks. Blockers: {list}.
Next: {first unchecked task ID and description}.
Key decisions: {brief list from this session}.

Include context beyond checkboxes for fresh session resume.

Wait for the user's choice before starting /phx:review or any other phase.

Step 6: Check for Additional Plans

After completion, use Glob to find other plan files matching .claude/plans/*/plan.md. If pending plans exist, inform the user. Do NOT auto-start.

Integration

/phx:plan → /phx:work (YOU ARE HERE) → /phx:review → /phx:compound
                 ↑ ASK USER before each transition

References

  • ${CLAUDE_SKILL_DIR}/references/execution-guide.md -- Task routing, parallel execution, verification
  • ${CLAUDE_SKILL_DIR}/references/resume-strategies.md -- Resume modes and state persistence
  • ${CLAUDE_SKILL_DIR}/references/file-formats.md -- Plan and progress file formats
  • ${CLAUDE_SKILL_DIR}/references/error-recovery.md -- Error handling and blockers
  • ${CLAUDE_SKILL_DIR}/references/harness-patterns.md -- Critic-refiner pattern for debugging loops
Files (claude-elixir-phoenix)
  • references
    • error-recovery.md 1.7 KB
      Loading…
    • execution-guide.md 10 KB
      Loading…
    • file-formats.md 1.4 KB
      Loading…
    • harness-patterns.md 3 KB
      Loading…
    • resume-strategies.md 1.9 KB
      Loading…
  • SKILL.md 7.3 KB
    ---
    name: work
    description: Execute Elixir/Phoenix plan tasks with progress tracking. Use after /phx:plan to implement features with mix compile and mix test verification after each step, or --continue to resume interrupted work.
    effort: high
    argument-hint: <path to plan file>
    ---
    
    # Work
    
    Execute tasks from a plan file with checkpoint tracking and verification.
    
    ## Usage
    
    ```
    /phx:work .claude/plans/user-auth/plan.md
    /phx:work .claude/plans/user-auth/plan.md --from P2-T3
    /phx:work --skip-blockers
    /phx:work  # Resumes most recent plan
    ```
    
    ## Arguments
    
    - `<plan-file>` -- Path to plan file (optional, auto-detects recent)
    - `--from <task-id>` -- Resume from specific task (e.g., `P2-T3`)
    - `--skip-blockers` -- Continue past blocked tasks
    - `--continue` -- Resume IN_PROGRESS plan from checkboxes
    
    ## Iron Laws (NON-NEGOTIABLE)
    
    1. **NEVER auto-proceed** to /phx:review or any next workflow
       phase -- always ask the user what to do next
    2. **AUTO-CONTINUE between plan phases** -- when Phase N completes,
       immediately start Phase N+1. Do NOT stop or ask for permission
       between phases. Only stop at BLOCKERS or when ALL phases are done.
    3. **Plan checkboxes ARE the state** -- `[x]` = done, `[ ]` = pending.
       No separate JSON state files. Resume by reading the plan.
    4. **Verify after EVERY task** -- never skip verification
    5. **Max 3 retries then BLOCKER** -- don't keep retrying forever
    6. **Stage specific files** -- never use `git add -A` or `git add .`
    7. **Read scratchpad BEFORE implementing** -- scratchpad has dead-ends
       and decisions that prevent rework. Step 2 is not optional.
    8. **Clarify ambiguous tasks** -- ask the user rather than guessing
       when a plan task's intent is unclear
    
    ## Step 1: Research Decision
    
    Ask the user for plans with >3 tasks:
    
    > This plan has {count} remaining tasks across {count} phases.
    >
    > 1. **Start working** -- Begin immediately (familiar patterns)
    > 2. **Quick research** -- Read source files first (~10 min)
    > 3. **Extensive research** -- Web search + docs (~30 min)
    
    Skip for plans with 3 or fewer simple tasks -- just start.
    
    > **Split warning**: Plans with >10 tasks risk 2-3 context
    > compactions. Suggest splitting via `/phx:plan` if not already.
    
    ## Step 2: Check Context (MANDATORY)
    
    Read scratchpad and compound docs before writing any code — skipping
    this causes rework. Read `.claude/plans/{slug}/scratchpad.md` (short,
    critical context) for dead-ends and decisions, then Grep `.claude/solutions/`
    for solved patterns. Apply findings: skip dead-ends, follow decisions,
    reuse patterns. Ask the user when a task's intent is ambiguous — never
    guess, corrections are expensive.
    
    ## Step 3: Load, Create Task List, and Resume
    
    Read plan file, count `[x]` (completed) vs `[ ]` (remaining).
    Find first unchecked task by `[Pn-Tm]` ID.
    
    **Create Claude Code tasks** only 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). Without it, skip every
    `TaskCreate`/`TaskUpdate` step in this skill — plan checkboxes and `progress.md` are the state:
    
    ```
    For each unchecked `- [ ] [Pn-Tm] Description`:
      TaskCreate({
        subject: "[Pn-Tm] Description",
        description: "Full task details from plan",
        activeForm: "Implementing: Description"
      })
    ```
    
    Skip already-checked items (`[x]`). Set `blockedBy` between phases
    (Phase 2 tasks blocked by Phase 1 tasks).
    
    With `--from P2-T3`: Skip to that specific task.
    
    **Stale-plan check**: if the plan predates this session (file mtime), spot-check
    2-3 files it references before executing — assumptions may have drifted.
    
    See `${CLAUDE_SKILL_DIR}/references/resume-strategies.md` for all resume modes.
    
    ## Step 4: Execute Tasks
    
    Execute each unchecked task (`- [ ] [Pn-Tm][agent] Description`):
    
    1. **Start task**: `TaskUpdate({taskId, status: "in_progress"})`
    2. **Route** by `[agent]` annotation (see `${CLAUDE_SKILL_DIR}/references/execution-guide.md`)
    3. **Implement** the task
    4. **Verify**: `mix format` + `mix compile --warnings-as-errors`
       (at phase end, also run `mix test <affected>` — see tiers below)
    5. **Complete task**: Mark checkbox `[x]` on pass, **append
       implementation note** inline, AND
       `TaskUpdate({taskId, status: "completed"})`. Example:
       `- [x] [P1-T3] Add user schema — citext for email, composite index on [user_id, status]`
       This survives context compaction; the plan is re-read on resume.
    6. **On failure**: retry up to 3 times, then create BLOCKER
       and write DEAD-END to scratchpad (see error-recovery.md)
    
    **Parallel groups**: Tasks under `### Parallel:` header spawn
    as background subagents. See `${CLAUDE_SKILL_DIR}/references/execution-guide.md`
    for spawning pattern, prompt template, and checkpoint flow.
    
    **Verification tiers** (scoped to minimize redundant runs):
    
    - Per-task: `mix compile --warnings-as-errors` only
      (format is checked by PostToolUse hook automatically)
    - Per-phase: `mix compile --warnings-as-errors` + `mix test <affected_files>` + `mix credo --strict`
      (scope tests: `mix test test/path/to_affected_test.exs` — NOT full suite)
    - Per-feature (Tidewave): behavioral smoke test via `project_eval`
      (create record, fetch, verify -- see execution-guide.md)
    - Final gate: `mix test` (full suite — run ONCE at the end, not per-phase)
    
    **Token efficiency**: Write user-facing text for non-obvious decisions
    and failures; routine verification passes need no commentary. When
    several checkboxes complete together (parallel groups, resume catch-up),
    batch them into ONE edit pass — never one Edit call per checkbox.
    The PostToolUse hook checks formatting but does NOT modify files —
    run `mix format` explicitly during verification or before committing.
    
    ## Step 5: Completion
    
    Summarize results with `AskUserQuestion`:
    
    > Implementation complete! {done}/{total} tasks finished.
    > {count} files modified across {count} phases.
    
    Options: 1. **Run review** (`/phx:review`) (Recommended),
    2. **Get a briefing** (`/phx:brief` — understand what was built),
    3. **Commit changes** (`/commit`), 4. **Continue manually**.
    If any task fixed a non-obvious bug, also mention `/phx:compound`
    to capture the solution.
    
    With blockers: list them, offer **Replan** (`/phx:plan`),
    **Review first** (`/phx:review`), or **Handle myself**.
    
    **If blockers remain**, auto-write HANDOFF to scratchpad:
    
    ```markdown
    ### [HH:MM] HANDOFF: {plan name}
    Status: {done}/{total} tasks. Blockers: {list}.
    Next: {first unchecked task ID and description}.
    Key decisions: {brief list from this session}.
    ```
    
    Include context beyond checkboxes for fresh session resume.
    
    Wait for the user's choice before starting /phx:review or any other phase.
    
    ## Step 6: Check for Additional Plans
    
    After completion, use Glob to find other plan files matching
    `.claude/plans/*/plan.md`. If pending plans exist, inform the
    user. Do NOT auto-start.
    
    ## Integration
    
    ```text
    /phx:plan → /phx:work (YOU ARE HERE) → /phx:review → /phx:compound
                     ↑ ASK USER before each transition
    ```
    
    ## References
    
    - `${CLAUDE_SKILL_DIR}/references/execution-guide.md` -- Task routing, parallel execution, verification
    - `${CLAUDE_SKILL_DIR}/references/resume-strategies.md` -- Resume modes and state persistence
    - `${CLAUDE_SKILL_DIR}/references/file-formats.md` -- Plan and progress file formats
    - `${CLAUDE_SKILL_DIR}/references/error-recovery.md` -- Error handling and blockers
    - `${CLAUDE_SKILL_DIR}/references/harness-patterns.md` -- Critic-refiner pattern for debugging loops
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.