Both low code and Rails have become a lot less relevant since LLM assisted coding became the norm.
Low code became less relevant because 1. LLMs solved many of the problems low code solves with better control over the output, and 2. you can’t use many low code platforms as an output from LLMs or other types of models (yet).
Rails became less relevant because Ruby is dynamically typed, and this poses a challenge for LLMs due to hallucinations. You don’t want to find out at runtime what things were complete bs from the model. Static typing isn’t a panacea to hallucinations but it’s a significant enough advantage, especially against such a dynamic language as Ruby. Even mere mortals struggle to understand the magic in meta programming DRY golf that many in the Ruby world have chosen to embrace.
EDIT: Any down voters care to explain why you disagree?
I agree that LLMs capabilities with a language are going to be extremely relevant. Community, API consistency, and whatever other factors that are going to increase LLM usefulness will decide the popularity of languages in the coming years.
I’m not sold on the importance of static typing though. I’ve had great results with Ruby and Python with 4o, o1, and to a limited degree Copilot.
One of the biggest benefits of Ruby is how simple testing is. The language is so dynamic that mocking/stubbing and intercepting or whatever is dead simple stupid.
So the “static types prevent you using LLM hallucinations” does not hold for me. I’m going to write tests covering the method (which the LLM will probably help with), and I’m going to get an undefined method error.
It's very evident this is the case if you generate similar JavaScript or TypeScript.
The types mismatching can really help you spot mistakes early on instead of at runtime, plus with the LLM generating trivial boring types is very straightforward.
The same effect is visible in Rust too and you'll quickly catch APIs that don't exist or that are being used incorrectly - albeit LLM understanding of Rust is really bad compared to other mainstream languages
As much as I love Ruby and Rails (and Elixir even more so), the IDE type checking of Typescript combined with LLMs is insanely productive. So I tend to agree, despite very much disliking node/JS and it's ecosystem. I've never been so productive in terms of getting ideas out of my head into functional products (ideate with Claude then start with bolt and move to Cursor after tapping that out).
The post isn’t about LLMs. Why not say LLMs have become less relevant since the advent of Ruby on Rails? It seems to me they’d be worse than both options presented in the post.
Has it? I don't think many here would agree it is the new norm
> better control over the output
LLMs are notorious for inconsistent output. Deterministic code gen is predictable. The control of a SaaS style low-code project may be limited, some offer to eject the codebase for you. There are numerous open frameworks, like Rails, where you have full control. It's about how you define control. Using a magic box like an LLM to generate code inconsistently comes with a lot of headaches. Why not choose the predictable magic box like Rails?
> Any down voters care to explain why you disagree?
Talking about downvoting typically earns more downvotes because it is against the posting guidelines
Anecdotally, my entire engineering team chooses to use LLM assistance because they feel more productive with it
> Talking about downvoting typically earns more downvotes because it is against the posting guidelines
I’m fine with the down votes. I asked because there were no comments, which makes for a pretty boring discussion. Now there are some comments. Thank you for leaving yours
Wicket is the best library I've ever used. Not just best webapp library or best Java library, the best library anywhere. If server-side rendering is an option then I'd absolutely use that (possibly from Scala).
Yes, sounds like, but it isn't. There is no logic inside html templates apart from wicket-specific component binding tags and everything happens in Java.
This is going to be largely dependent on your needs, but a factor I would consider if you're using LLMs for coding is which models have been trained the most on which languages. The more a model has been trained on a particular language, the less it will hallucinate
I'm currently building an internal app with Pico CSS, htmx and ASP.NET minimal APIs returning Razor components and it's a joy. I'm a Developer DBA with no perfessional front end experience but I feel really productive and the final results look great.
I don’t rely on LLMs as much as I did when copilot came out, but I 100% agree regarding static types: they make it so much easier to tell when the LLM is spewing nonsense. I probably wouldn’t use one at all with a dynamically typed language.
the key is to not generate huge big spurts of code blocks but incremental, reviewable code blocks in dynamic typed languages. Also,
“LLM”s are a constantly updating product, the new DeepSeek coder model with GPT-o1 like reasoning and chain of thought just came out, and its a lot superior than LLM models from even 1 month ago, especially when trained on internal docs, and files, and synthetic LLM generated metadata on those files, all accessible under an effective hybrid search engine.
It’s perfectly usable with Dynamic languages like JS and Python, and perfectly doable to write bug free effective code, is one is restrained and thoughtful in its use, which builds up as muscle memory over time anyways.
Especially if one considers linters and type hints enabled in js (as ts) and python type hints, then it becomes even more doable, if you’re insistent on static typed only language code with LLM.
It's marginally better compared to Claude and costs 10x. O1 is not a solution.
I agree there is plenty of space for improvement on the IDEs side, they need to start fetching code of dependencies and documentation dynamically, get the relevant context and pass it in the prompt to the LLM, so that they can use real code and not what the model remembers from training a certain library does.
Low code became less relevant because 1. LLMs solved many of the problems low code solves with better control over the output, and 2. you can’t use many low code platforms as an output from LLMs or other types of models (yet).
Rails became less relevant because Ruby is dynamically typed, and this poses a challenge for LLMs due to hallucinations. You don’t want to find out at runtime what things were complete bs from the model. Static typing isn’t a panacea to hallucinations but it’s a significant enough advantage, especially against such a dynamic language as Ruby. Even mere mortals struggle to understand the magic in meta programming DRY golf that many in the Ruby world have chosen to embrace.
EDIT: Any down voters care to explain why you disagree?