Claude Code Plugin for Elixir: Custom Skills and Hooks for Better Code

Quality

I’ve been experimenting with Claude Code for Elixir development and built a
custom plugin to improve code quality. To test whether it actually makes a
difference, I built the same Phoenix LiveView application twice once with
minimal configuration and once with the full plugin.

The Experiment

I created an image gallery application with Phoenix LiveView featuring:

• Image uploads with progress tracking
• Folder organization
• Tab-based navigation
• Responsive TailwindCSS UI
• Local file storage with PostgreSQL metadata

Build 1 (Baseline): Minimal configuration, just project guidelines and
specs
Build 2 (Plugin): Custom skills, hooks, agent docs, and comprehensive
project documentation

What’s in the Plugin?

4 Custom Skills:

• Elixir patterns (pattern matching, pipe operators, with statements)
• Phoenix LiveView (lifecycle, uploads, streams)
• Ecto database (schemas, changesets, queries)
• Error handling (tagged tuples, error patterns)

5 Validation Hooks:

• Warn on nested if/else (prefer pattern matching)
• Block hardcoded config values (require Application.get_env/2)
• Warn on Enum.map |> Enum.filter chains
• Block missing @impl true on callbacks
• Warn on string concatenation in loops

Agent Documentation:

• Project structure and context boundaries
• LiveView implementation checklists
• Ecto conventions and best practices
• Testing guides

The Results

Where the Plugin Excelled

1. Comprehensive Testing
Build 2 included 46 automated tests covering all context operations, edge
cases, and error handling from the start.

2. Better Code Quality
Consistent pattern matching, proper pipe operator usage, tagged tuples for
error handling, and @impl true on all callbacks.

3. Idiomatic Elixir
The plugin encouraged idiomatic patterns throughout:

# Pattern matching over if/else
def process({:ok, result}), do: transform(result)
def process({:error, reason}), do: handle_error(reason)

# with statements for multi-step operations
def create_image_with_folder(attrs, folder_id) do
  with {:ok, folder} <- get_folder(folder_id),
       {:ok, image} <- create_image(attrs) do
    {:ok, %{image: image, folder: folder}}
  end
end

Important Limitation

Both builds required manual testing to catch functional issues. The plugin
helps write better code with proper patterns and conventions, but it cannot
replace human validation of feature functionality.

The Verdict

The plugin produces higher-quality, more maintainable code with better test
coverage. If you're building Elixir applications professionally, the
investment is worth it.

Try It Yourself

The plugin configuration is available on GitHub:

https://github.com/j-morgan6/elixir-claude-optimization

The package includes:
- Skills for Elixir patterns, LiveView, Ecto, and error handling
- Hooks that enforce conventions and warn about anti-patterns
- Agent documentation for project structure and testing
- Sample CLAUDE.md for project setup

This is a one time investment that's reusable across all your Elixir projects.
 I'd love to hear your thoughts or experiences with AI-assisted Elixir
development!