Over the past year, my stack for personal projects took a winding path: vanilla Rails with Hotwire → Rails with Inertia and React → Phoenix LiveView.
Rails remains an incredible framework, but exploring Phoenix—especially alongside AI tools like Tidewave.ai—made me rethink what stack works best for my solo projects.
How I Got Here: Hotwire to React
When building interactive side projects with Rails:
- Hotwire: I liked the server-rendered philosophy, but building complex UI widgets (comboboxes, multi-state dialogs) felt painful because my CSS skills are limited.
- Rails + React (Inertia.js): Moving to React gave me access to shadcn/ui and allowed fast component prototyping with AI. But over time, React fatigue set in: managing state across the client/server boundary, handling Node.js build pipelines, and constant context switching between Ruby and TypeScript.
I wanted the single-language simplicity of server-rendered HTML, but with modern real-time interactivity and good default UI components.
Why Phoenix LiveView Clicked
1. Single Paradigm, Zero Build Step
LiveView’s mental model is straightforward: state lives on the server process (a lightweight BEAM process), and UI updates stream over a WebSocket connection.
There is no client-side state synchronization library, no REST/GraphQL glue code, and no frontend bundle compilation to wait for. Everything is written in Elixir.
2. Built-in Tailwind & DaisyUI
Phoenix ships with Tailwind CSS and DaisyUI out of the box. While DaisyUI’s default aesthetics aren’t for everyone, having pre-styled components (tabs, modals, alerts, badges) already wired up eliminated the styling bottleneck that pushed me toward React in the first place.
3. Better Fit for AI Code Generation
This was the unexpected part. When using AI coding tools like Claude Code and Tidewave (an MCP tool tailored for Phoenix):
- Single context: Because a LiveView component encapsulates state, lifecycle callbacks, and HTML template in Elixir, the AI has the full context in one file rather than across controllers, serializers, and React components.
- Explicit state & pattern matching: Elixir’s functional nature and immutable data structures make business logic explicit. AI models tend to produce fewer hallucinated state bugs in Elixir than in multi-tier JavaScript state graphs.
In a recent personal project, Tidewave generated nearly the entire LiveView CRUD and UI workflow based on high-level feature prompts, with minimal debugging required.
The Trade-offs
Phoenix isn’t without friction:
- Ecosystem size: The Rails ecosystem is enormous; if you need an integration for an obscure third-party service, Rails almost certainly has a mature gem for it. In Elixir, you occasionally need to write your own wrapper.
- Learning curve: Functional programming, OTP, and pattern matching require a mindset shift if you’ve spent years in object-oriented Ruby.
Summary
Moving to Phoenix LiveView gave me the best of both worlds for solo development: the component convenience I wanted from React, combined with the server-rendered, single-language simplicity I missed from vanilla Rails. For personal projects where developer velocity and low maintenance overhead are top priorities, it has become my go-to choice.