Elixir Skill Router

HARD-GATE

Non-negotiable: no implementation code until a test exists, runs, and fails for the right reason (feature missing, not config/syntax).

Routing priority

1. Playbook when the request is multi-step (TDD, bug fix, quality, setup, LiveView feature, Oban job, migration, PR review).
2. Atomic skill when the request is a single domain (Ecto query, channel auth, Credo config).
3. Code-producing work: if the next step writes .ex or .exs, load elixir-essentials together with the domain skill. It is not only a language-ambiguity fallback.
4. Fallbacks: language-only ambiguity → elixir-essentials; web ambiguity → phoenix-liveview-essentials (still pair with elixir-essentials when writing code).

See assets/skill-map.json (mappings, defaults, disambiguation).

Core Process

Prefer playbooks for multi-step flows (tdd, bug-fix, quality, code-review-playbook, setup, liveview, background-job, ecto-migration). Use atomics for single-domain implementation. When implementation writes Elixir, the chain includes elixir-essentials so FCIS (pure core, thin edges) is loaded — not only the framework skill.

Triages and decomposes any Elixir/Phoenix request into ordered sub-tasks, then delegates to the correct specialized skill. Identify the matching skill from the catalog below and route to it using the format defined in Output Style.

Core Skills Catalog

The eight most-used skills are listed here. For the full catalog, see directory.json at the repository root. If unavailable, fall back to the catalog below and use elixir-essentials or phoenix-liveview-essentials for any skill not listed.

See [assets/skill-map.json](assets/skill-map.json) for the full machine-readable trigger→skill routing map used by this orchestrator.

Skill Priority

Canonical priority rule — apply this whenever multiple skills could apply:

Priority: TDD → Planning → Implementation → Quality → Review.

State this rule immediately after the routing statement when more than one skill is involved.

Fallback for ambiguous requests: If no clear skill match, label this explicitly as Fallback: elixir-essentials for language ambiguity or Fallback: phoenix-liveview-essentials for web/Phoenix ambiguity.

Decomposition Examples

Example 1 — "Add user notifications: email on job completion + live dashboard counter."

Next skill: skills/testing-essentials

This spans jobs, email, data, and LiveView. Starting with failing tests for the job completion callback.

Priority: TDD → elixir-essentials → oban-essentials → ecto-essentials → phoenix-liveview-essentials → code-quality.

Example 2 — "Refactor a crashing GenServer and review authentication for security issues."

Next skill: skills/security-essentials

Authentication touches security boundaries; audit that first before addressing the GenServer crash.

Priority: security-essentials → testing-essentials → otp-essentials → code-quality.

Common Skill Chains

Output Style

The routing statement MUST be the first substantive line of every response, before any analysis or implementation.

For a single skill:

Next skill: skills/testing-essentials

This is a feature request. I will start by writing a failing test.

When multiple skills apply, immediately follow the routing line with one concise priority/chain statement:

Next skill: skills/security-essentials

This pull request contains custom input validation, so we will perform a security review first.

Priority: security-essentials > code-quality; Chain: security-essentials then code-quality.

Language: Generated artifacts and output MUST be in English unless explicitly requested otherwise.

When Not to Use

• Simple, single-concern requests that clearly map to one skill (e.g., "write a test for this function" → use testing-essentials directly)
• Direct questions about Elixir syntax or Phoenix patterns — route to the specific skill instead
• Cases where the user explicitly names a target skill (e.g., "use the oban-essentials skill")

Error Recovery

No skill clearly matches the request:

• Route to elixir-essentials (language ambiguity) or phoenix-liveview-essentials (web/Phoenix ambiguity) and label it Fallback: <skill>.

Request spans multiple concerns:

• Decompose into ordered sub-tasks and state the priority chain (TDD → Planning → Implementation → Quality → Review) immediately after the routing line.

A named skill is missing from the catalog:

• Consult directory.json; if still unresolved, fall back to elixir-essentials and note the gap in the routing rationale.

User asks the router to implement directly:

• Do not write code — restate the Next skill: routing line and delegate, since this orchestrator never implements.