dewetblomerus
Building with Ash, Before & After AI
It’s been almost two years since I built something with Ash, and LLMs have significantly changed my workflow since then. After trying it on a new side project this month, I have some new thoughts on Ash.
LLMs have made the task of generating working code much easier. This means that the human programmer spends a larger portion of their coding time reviewing code. I think the benefits of Ash shine brighter in this scenario. I wrote a longer form version of this here.
I’d be curious to hear other opinions on a thought experiment:
If LLMs got 5x better than they are today at quality, speed & cost. Assuming you can very quickly be presented with working code that at least achieves a reasonable interpretation of the initial prompt.
If in this new reality, your responsibilities as a software engineer is:
- Ensure that the resulting code does what the business needs.
- Ensure that it’s built in a way that when the stakeholders change their minds, the resulting changes will be made in a reasonable timeframe.
- Ensure that when other engineers or LLMs come to work on the project, they can copy the existing patterns without making you sad.
- Ensure that we can either handle the “ilities” (reliability, observability, usability, maintainability, operability, etc.) now, or can make reasonable changes (no re-writes) to handle them if we run into massive success & scale in the future.
In that utopian/dystopian future, would you rather be reviewing Ash code or something else?
In my opinion, Ash wins here because I would have so much less code to review and because different dimensions of the same functionality (auth, code interface, relationships, persistence) are all organized in a way that I can review one of those dimensions at a time without having to load all the others into my brain.
What would you choose?
Most Liked
ken-kost
elixir is also niche but I believe it also saves tokens, as Jose made a blog post about on why that might be so. But abstracting the functional into declerative achives what you said - greater offload. this new nondeterministic tool couples well with any kind of deterministic tooling. I think in the coupling the real intelligence emerges, it’s relational.
And to your last point, with proper context (usage_rules) llm’s mistakes boil down to a minimum. For example I had an issue where it would write good ash code except for interfaces - it would write regular functions inside the domain. With two new lines in usage rules it started writing interfaces with no problem.
In any case, my emphesis is in the coupling; I think elixir (and ash) vibe well with ai. ![]()
nxy7
I’m digging out old thread here, but I’d say that LLM coding is big win for Ash. In my mind anything that decreases ‘code surface’ is big win for AI. There’s a lot of ways to mess up transactions/logic/authorization (any cross cutting concern really is a burden for AI), but with declarative approach it’s much better.
In my experience mistakes that AI makes with Ash are trivial (things don’t work) but once it plugs thing in correctly it usually works fine.
I guess what I’m trying to say it helps that with Ash you offload more work to the framework so AI code has less surface. Also perhaps maybe there’s tiny chance that declarative code burns less tokens (but this would very likely be offset by the fact that Ash is more niche so LLMs can make mistakes and run additional cycles).
dewetblomerus
I haven’t done any serious side-projects in a while. But something I did try on some small things here & there that turned out well, was to spend a lot of time vibe-coding markdown files with mermaid diagrams, descriptions of what the MVP should do, entity relationship diagrams for how the database schema should look. I only review the rendered markdown & diagrams, not the raw markdown that generate them.
This allows my 2026 attention span to still carefully comb through the details that matter, and the database schema which is easier to just plan up front and get right the first time than iterate on after valuable data is entered.
And when I have all that in the state that I want, I just tell the LLM to build it in vanilla Phoenix.
That’s the long way of saying I’ve tried a bit of the same @johns10davenport and I can confirm that at least for small side projects, the agents of 2026 do very very well at building Phoenix/LiveView code that they can also maintain over time.
Last Post!
johns10davenport
I’ve done significant large scale/long horizon development tasks. I’ve experimented with a lot of different techniques. The most effective thing I’ve found to do is refine and generate bdd specs that define what the application needs to do, design your phoenix context architecture and let the model write code in that structure till the tests pass. Llms are extremely effective at writing phoenix apps in this context.
Popular in Discussions
Other popular topics
Categories:
Sub Categories:
Forums
Popular Tags
- #ecto
- #liveview
- #troubleshooting
- #learning-elixir
- #deployment
- #library
- #erlang
- #testing
- #genserver
- #mix
- #absinthe
- #remote-other
- #otp
- #plug
- #how-to-question
- #macros
- #postgres
- #channels
- #elixirconf
- #exunit
- #discussion
- #code-sync
- #javascript
- #podcasts
- #onsite
- #dialyzer
- #docker
- #authentication
- #umbrella
- #full-time-contract
- #podcasts-by-brainlid
- #ecto-query
- #elixir-ls
- #phoenix_html
- #iex
- #blog-post
- #graphql
- #genstage
- #ai
- #websockets
- #supervisor
- #elixirconf-us
- #advent-of-code
- #distillery
- #processes
- #forms
- #api
- #metaprogramming
- #security
- #hex









