elixir-production

Research state-of-the-art algorithms for a problem

Create or run Benchee benchmarks

Analyze code cognitive load and onboarding difficulty

Analyze distributed system design and correctness

Implement a new feature with architecture planning and parallel exploration

Document patterns in project-learnings.md

Review a GitHub PR against standards

Run full precommit quality checks

Comprehensive code review against production standards

Upgrade SPIKE code to production quality

Fast iteration mode for experiments without production requirements

Use when a problem needs novel algorithmic approaches, academic paper citations, or evaluation of cutting-edge data structures not covered in the algorithms skill

Use when actively analyzing a specific module or codebase for cognitive load, onboarding difficulty, or refactoring opportunities

Use when designing a distributed architecture, investigating a distributed bug (split-brain, state disagreement, partition recovery), or evaluating consensus algorithm tradeoffs for a specific system

Use when a feature needs architectural design before implementation, including complexity analysis, test specification, and phased implementation strategy

Use when implementing Elixir code after a plan exists, or when writing new functions, modules, or features that need tests written first

Use when code changes need review against production standards, before committing, or when checking if implementation is production-ready

Use when actively profiling slow code, running benchmarks to compare implementations, or investigating a specific performance bottleneck with measurement tools

Use when building or debugging Phoenix LiveView features that need guided implementation, not just pattern lookup

Use when reviewing a GitHub pull request by number, or when validating a PR is ready to merge

Use when designing a test strategy for a feature, analyzing behavioral coverage gaps, or specifying which test cases to write with criticality ratings

Use when choosing data structures, Map vs ETS vs gb_trees performance, evaluating hash functions, needing HyperLogLog or bloom/cuckoo filters, or comparing OTP built-ins against specialized alternatives for Elixir

Use when code is hard to understand, a module has too many parameters or deep nesting, functions exceed 40 lines, abstractions feel leaky, or you need to evaluate deep-module vs shallow-module design per Ousterhout principles

Use when building multi-node Elixir systems, choosing between Raft and CRDTs, configuring libcluster or Partisan, debugging split-brain or netsplit scenarios, or evaluating CP vs AP tradeoffs

Use when structuring Elixir code, deciding whether to use GenServer or plain functions, designing supervision trees, handling overload or unbounded message queues, organizing Phoenix contexts, or needing idiomatic OTP patterns

Use when about to run git commit, git push, or claim implementation is complete in an Elixir project — requires running mix precommit and confirming output before any commit or completion claim

Use when code is reported slow, before suggesting any optimization, when choosing between cprof/eprof/fprof/tprof, or when creating Benchee benchmarks to compare approaches

Use when working with Phoenix LiveView, Plug pipelines, controllers, JSON APIs, channels, streams, forms, phx-hook, authentication, or debugging Phoenix/LiveView gotchas

Use when preparing code for production, running mix precommit, mix compile warnings-as-errors, mix credo --strict, mix format, mix test failures, adding typespecs, evaluating security posture, checking migration safety, or reviewing code before committing

4 hooks across 3 events