From the talk it’s clear, Rails needs to be forked.

isn't https://mosscap.dev/ a fork?

So it seems this started because of DHH. Let's judge the technology by the technology, else we are just taking a holier-than-thou approach whereby we think we are better than others because we don't commit certain sins, which is a real problem because when we look inwardly and honestly we shall see that we are guilty of many of the same sins. Let's judge the technology for the technology itself and leave personal ideology out of it. My 2 cents (which will inevitably be downvoted)

speak for yourself, I never compare people to shoot wolves

Heh. It's always funny how people like that don't see their irony of being "inclusive" of "all backgrounds" just after having made a long list of people who they will throw out immediately for vague transgressions that are based on rumors and innuendo.

Rails, or even more so php have VERY little to bring to the table in 2026 going forward. Rails (ruby) is still a saner language than PHP, but as slow as php is. (granted ruby is not idiotic like PHP and runs rather than start/die).

If you go the LLM route something like Go is probably the goto default for MOST networking/web-first apps. You get static types, and a fast compile cycle (rust is still very slow here), and IF you want more from the language you can use something like Lisette (https://lisette.run/).

Bottom line is dynamic languages are obsolete. There is really no benefits from using them outside very small throw away scripts.

Why would I bother with anything but Laravel for small CRUD apps? Not having to think about concurrency is neat, having tons of abstractions built by people with 50x my experience is neat, just being able to get going is neat.

Building the things I've built using Laravel with Golang would probably take 10x the development time as I have to handcraft everything Laravel already natively provides. Or I have to trust 100 packages from 100 different random devs to simulate the Laravel experience in Golang.

With LLMs the language DOES NOT MATTER. The framework DOES NOT MATTER. This is the thing we are talking about here. Laravel is 100% useless for a LLM first project. I can pretty much do anything in vanilla Go i can in Laravel and be 100x more performant, 100x more typesafe, and produce 100x more maintainable systems.

This is why dynamic languages, and even more so BAD ones like PHP are just useless going into 2027 and the future. Its simple, the language gives you what it gives in perf, builtin RUNTIME features, and COMPILETIME features.

From that you pick the best for whatever you are building, be it Go, Rust, Ocaml etc. The language does not matter.

Go has 90% of stuff builtin, you rarely need any dependencies. Look at Laravel ITS A HUGE CODEBASE and a high risk for any real software project. I would stay FAR away from it.

as slow as PHP is.

Citation needed? I love hating PHP, but of the reasons I would chose something other than PHP, speed and resource consumption is pretty far down the list?

PHP is sync. This means every IO operation i do runs sync. This is why PHP will always be the slowest ones out there. Open a file, SQL queries, sending emails etc. Its all sync. Its all slow.

PS. I fully aware of hacks around this like reactphp and the other related async things, but those are all just heavy dependencies and for most sane devs non starters.

PHP is significantly faster than Ruby.

The summary is exactly why a lot of people is upset.

That’s what bothers me most. I’m skeptical of his AI claims, but that’s not the real issue here.

The problem is that he stood up at Rails World and told everyone that he was moving his product off Rails and the best thing he could come up with to say to people still using Rails was that we’re “the best of the best.” Thanks, I guess.

Maybe Rails is done, in the way the Mosscap project claims. Maybe it’s time to focus on stability and maintenance. If that’s the plan, someone needs to say it. If it isn’t, then let’s hear about where we’re headed. DHH did neither.

It's kind of crazy to witness.

Rails is very insular tech.

A lot of people bet their entire careers on Rails. I've worked on Rails shops, and the majority of developers have not touched another language in years. There are people who never shipped anything in anything but Rails, and haven't done anything in other language since college, or ever if they did a bootcamp.

I have even interviewed a significant number of people doing Rails for ten years who did not know it was possible to launch a Ruby application with `ruby script.rb`.

Not to mention that with the emergence of frontend frameworks, most Rails developers were doing API-only stuff, and barely interacted with the frontend.

I recently left a company that was moving to from Rails to Go (might have been partially my fault), and there were was a bit of a mutiny where several teams have refused to change languages.

DHH is pretty much saying AI is gonna eat this people alive.

These people who refer to them selves as a "Rails Engineer" (or substitute any other language/framework) and fail to realize that there are other tools in the box are of course first against the wall in the AI-driven future.

A carpenter who only knows how to use a hammer isn't a very good carpenter.

Why is Rails a hammer not Milwaukee/DeWalt/Makita/etc? A carpenter with only DeWalt brand power tools will do just fine.

37signals differentiates their products with opinionated UI/UX, not novel features. They are rewriting Hey as six native apps because the web fidelity isn’t good enough. So UI matters enough to justify complete rewrites, but also everyone just wants CLIs?

I've seen this one a few times lately. People should stop building UIs, nobody wants to interact with a UI. Everyone's app should just be an API that you can use with a chatbot. Except for my app — my app is a handcrafted miracle of artisanal UX and its UI will change the way you see the world.

It's exactly the old argument, just now with LLMs in the place of shell pipelines: in terms of functionality and value to users, software ought to be malleable and composable. We've known it since the eighties. But the model of selling a piece of software as a product as if it were a pair of shoes is incompatible with that. You need a big monolithic application to justify users paying a bunch of money for it, and you need it to have a fancy interface that makes an impression. And the whole software industry is built on top of that model. Where monolithic software is completely unfit for a purpose, like when it needs to be a component of a larger system, we rely on (mostly unpaid) OSS.

Except now LLMs let you, with very little technical know-how, plaster a ‘programmable’ interface on top of unstructured data/interface meant for humans, and because that's what we actually want, of course everybody does that. So the end result is a wildly expensive pipeline from API to UI and back to API again. I wonder how long the legacy ‘human-oriented’ layer in the middle, and the industry that's been built on top of it, will last.

(Separately, chatbots are not great as a UI for most things, and the problem of building the universal UI still also stands. But it turns out for a lot of things people would rather have a bad universal UI than a good special-purpose UI for each task.)

Everyone's app should just be an API that you can use with a chatbot.

I see this sentiment a lot, but UI has a greater purpose than just serving the customer needs, it also be used to shape them.

Imagine if instead of going to the grocery store, you called a number and told them what you needed. Sometimes you don't know everything you need. Sometimes you end up discovering something new and buying it even if you didn't plan on it.

Except now LLMs let you, with very little technical know-how, plaster a ‘programmable’ interface on top of unstructured data/interface meant for humans, and because that's what we actually want, of course everybody does that.

I don't think that is what everyone wants, or at the very least its not what I want. My ideal software has a well designed and thought through user interface for the primary interactions, allowing me to think about the goal I'm trying to achieve rather than how I'm manipulating the underlying data model.

Additionally to that please also provide access to the underlying data. Ideally in the form of a locally accessible API but I'll accept a remote one if necessary, provide a CLI on top of that as well if you like.

I think chat is a great entry point for many experiences. The approachability and flexibility are unmatched.

A question becomes, how do you evolve a chat experience to task specific actions?

I’m building an app to explore scripture. Chat is an amazing starting point. But it’s terrible once you get into reading the actual scripture.

I think we will see more of this in the future. Here is how I’ve envisioned evolving an experience out of chat. Curious if others have their own ideas.

https://trysojourn.app

For me personally, the effort to type on a mobile phone is too much. If I can't complete an interaction with maybe two sentences, I much much prefer typing on a computer, and if required, copy everything over.

I’m in the same boat. Hate typing on a phone. But due to chat interfaces,I’ve learned to mutter discretely into Apple keyboard dictation.

I like this way of branching and adding context for the user. It would be interesting to make it more generalizable to other texts.

I think LLMs may actually help us get to CLI/API driven development. At least, that has been my experience.

Even though most of my projects have a UI, I build a CLI/API version so that the LLM can interact with it directly. I have been using this "CLI driven development" approach for more than a year now and have had fantastic results. The CLI arguments make it easy for LLM to interact with software it wrote.

I usually ask LLM to build a lib, then expose as a CLI and a RESTful API.

in terms of functionality and value to users, software ought to be malleable and composable.

For technically competent users, sure. but for everyone else the UI should just follow the principal of least surprise.

UIs are great, until you can’t see the UI.

Words are a great UI. They can be easily converted into audio and haptics. We already have many systems in place that do exactly this with words.

Sure, pretty graphics are nice, but their sole intent should be to convey information. A User Interface that does not allow a person to easily have information conveyed to them is a bad interface.

The modern AI world isn’t perfect, but for a large portion of people who have accessibility needs, it’s absolutely a positive impact on their life in a way that no single technology has been until now.

A chatbot is worse than a CLI app: a CLI app does exactly what you ask for, and has a manual documenting exactly what command do what, and the output is consistent, the same command does the same thing period.

A chatbot using an LLM of course not, it suffers from hallucinations, it may do what you want but there is a change it won't and you have to fight it to get the desired result.

Chatbots are far WORSE than traditional UI for everything. If some product has a chatbot functions it's the first thing I disable, if it's not possible to disable it, I avoid the product.

And GUI applications are typically preferred, at least for the normal people and not us nerds, to CLI applications, since you know people like moving a mouse and clicking on buttons (or tapping them on a touchscreen) that learning commands: a chatbot doesn't make the CLI experience less awful for the average user, and for the nerd user, he prefers to use the CLI directly (replace asking the chatbot with man or --help and you don't need to emit tons of CO2 and transmit your personal data to a datacenter on the other side of the world to do stuff you did with MS-DOS)

a CLI app does exactly what you ask for, and has a manual documenting exactly what command do what, and the output is consistent, the same command does the same thing period

This is a very software-engineery point of view and totally false for the ordinary user. Heck, it is even false for me as a software engineer.

since you know people like moving a mouse and clicking on buttons

No, they like well-designed user interfaces, and the UI design of a typical CLI is abysmal.

Rails is dead.

Its founder has converted to AI driven Rust.

He has a point. Anything you could build in Rails you can now build in fast reliable type safe memory safe multithreaded Rust in minutes.

DHH will bring his tribe of true believers to where he has gone, where he has set up a new sideshow tent.

Do you follow the leader.

Is it Rails that you follow or is it DHH?

It is pretty obvious rails is dead as it hangs massively on its founder for good and for bad.

And it is quite telling that he prefers to kill it off like this rather than handing the reigns over to someone else.

A technical note - the big difference is that a design with a number of fat clients don’t need server side rendered html - that lowers the load on the server regardless of the programming language.

You can probably write quite light json apis in Ruby and the performance of them will be dominated by network and db usage anyways compared to a similar implementation done in a compiled language.

https://github.com/rails/rails/commits/main/

https://github.com/rails/rails/graphs/contributors?from=6%2F...

Zero commits are from DHH. It seems he already handed reigns over to other people.

DHH's keynote was like listening to David Brent give a motivational speech.

"Some of you will loose your jobs. I know, I know. Gutting. Gutting. On a more positive note, I'm getting a promotion. So every cloud. Oh, you're still think about the bad stuff aren't you?"

You have to laugh about it because he's kind of making himself irrelevant too. We listened to him because of Rails not Hey or Basecamp. They were just application of Rails as a technology.

If he no longer has a vision for Rails' niche, what do we need him for? What's his pitch?

He might as well just be a Danish Barry Gibb impersonator that can't sing but instead drones on and on about politics. :P

I laughed when he showed the slide that Hey could run on a single Raspberry Pi.

Not the flex you think it is, Dave!

The article forgets one thing, how DHH started his talk: he asked the audience how many people still codes by hand, and only 5 people raised their hands.

I was also waiting for some cool talk of some change, as I loved the simplificiation that Rails has done last year, but I also understand his point of view: he could either speed up the development of rails with AI (what Bun has done), or just say that it's mature and it doesn't matter anymore and it's better to not ruin a mature system.

Every piece of software has an expiration date. You can extend its lifespan, but technology keeps moving. What was considered standard on the backend five years ago may look completely different today. I think that's a good thing. Rails worked extremely well for its time, especially around 2007–2015, but it started to show its age as newer, more capable languages and runtimes matured.

We should be celebrating the fact that we can now port almost anything with far less effort, or modernize an existing stack to meet today's performance expectations, requirements, and engineering standards.

Whats the expiration date on, say, the windows 95 version of paint? Because it still loads just fine on my current windows computer, does everything I'd expect from a paint program, and gets out of the way when I don't need it anymore

What are the newer more modern frameworks? How are they better than Rails?

Well, you have these:

- Rust: Axum, Actix Web

- Go: net/http + Chi, Echo

- C#: ASP.NET Core

- Java/Kotlin: Spring Boot 4, Quarkus

- Elixir: Phoenix

- TypeScript: Fastify, NestJS

- Python: FastAPI, Django

But they fill different niches, there's no way I'm going to choose Rust+Axum as much as I love Rust for an ecommerce/CRUD vs something as batteries-included and expressive like Rails or Django.

Honestly Rails being finished it's that bad. If you aren't writing the code by hand what benefit is it really bringing to you now?

Rails niche was fast setup/low starting out costs and relatively constrained/medium maintenance costs. To get this you traded performance and type system. The latter usually resulted in increased maintenance costs as test suites ballooned to compensate.

These days fast setup is simply a product of AI, every ecosystem now offers fast setup. Maintenance costs are now about how token efficient it is to find and fix problems. Test suites are going to be huge everywhere now but there is some chance languages that require less to accomplish more will win on token efficiency and be favored.

Humans aren't the dominant factor in programming language design or selection anymore, that is a fact at this point it just hasn't sunk in for everyone yet.

We are only ~6mo in to agents being good enough to write code. A year from now our profession will be entirely changed. Agents will get better (how much? don't know) but importantly they will definitely get cheaper and access will be broader. Which is really the point DHH was trying to make.

Access and economics are finally going to do what no-code failed to do, which is democratise software. Maybe not to the point that everyone writes code or even that shit programmers are good, but it will enable shit programmers to write Rust which was literally impossible 6mo ago and they will have better programs as a result.

Which is the other thing he touched on. Good programmers are going to excel here and great programmers are going to dominate. I'm already seeing the 10x programmers hit 100x and 1000x with more access doesn't seem out of sight. It's also restoring the will to create in a lot of people that lost the passion for the mechanical part of programming, unlocking the experience and skill of these people that were otherwise considering cashing in the bag is huge.

So yes. Rails is done but what is coming next is way more exciting. I'm with DHH here, be glad it happened but get moving on where things are going to be instead of clinging to the past.

I code and maintain a Rails stack. About 20% of the time an endpoint takes to respond is spent in Ruby. New Relic tells me our Apdex is 99, and it’s very rare for an endpoint to take more than 100ms. Most respond in under 80ms. I could LLM-port it (and probably will one day), but end-user response performance wouldn’t be the motivation.

What does make me consider switching is reading about things like how Shopify’s native apps are moving towards superfast product cores that can be tested incredibly quickly, with the slower UX layer kept separate. I think that model is the future, and in that world Rails starts to look pretty dead.

As an SRE I would be very interested on experienced devs point of view on that stance, "we don’t even necessarily need to read the code the LLMs produce". To me, that is the only way a single dev can manage > 1 agent. Because I feel running the code will always be slower than a single agent generating it. On the other hand, it implies lack of human understanding on what is going on under the hood. Which is fine if you trust the LLM to write great code, and great tests for the code, but fundamentally you have to have 100% trust, 99.9% is not going to be enough in any serious industry, would it ?

Also eventually you'll also have to trust it to write the deployment code or even run the deployment itself, otherwise SRE is going to be the bottleneck. And only then should I feel anxiety about the rest of my career (that, or my employer decide LLM are good enough to get rid of me, even if they are imperfect).

Because I feel running the code will always be slower than a single agent generating it.

That is very not true for many cases. Agents generating code are usually painfully slow, finding workflows that replace that reasoning with running code usually speed things up in my experience.

Not trying to be a jerk but at this point SRE is my main use case for heavy LLM stuff. It's pretty awesome at that. Deployments and CI pipelines have become a breeze. I used to have to ask DevOps for that and wait days. I have even let agents run deployments for side projects and they seem to do better work than most humans I've worked with. It's wild they will actually read all the logs and debug problems so fast. Not something we could ever keep up with.

The actual code and architecture is where it still lacking IMHO. Especially in rails... Like it will just build the least scalable features if you let it do it's thing. Ten queries for what could be one. No separation of concerns. Huge files, lots of duplicated code and then tens of thousands of units tests that just grow like a fatberg.

If your app does anything serious, if you have serious traffic... you are going to need to review each session finely (and your DB schema with each deploy). It could be that this is maybe an indictment of rails more than LLMs, I guess maybe time will tell.

We are many of us now engaged in a big experiment to see just how little you can read the code, and for how long. Considering the consensus is that we have still not yet passed the 1 year anniversary of agents getting good, it feels too early to say how it will play out. But there are a lot of market forces working to make it happen.

Which is fine if you trust the LLM to write great code, and great tests for the code, but fundamentally you have to have 100% trust, 99.9% is not going to be enough in any serious industry, would it ?

This is lacking a lot of nuance. There are many types of code. There are many situations where I'm analysing something one-off and if I get 33% success ratio, but can easily verify the result, I'm happy - still saved me time and money. They're are situations where I'm generating graphs from some dataset and I don't have to trust anything - I know what the result should look like, I just need the agent to drive matplotlib. There are low stakes dashboards which I'm happy to generate and develop entirely via agents - they'll embed the updated screenshots in PRs that I can yolo-merge - worst case is that someone complains about something not working next time they visit. Then there's lots of experimenting which was never stopped to hit production anyway.

Finally after all of that you get code that's actually part of deployable features. Of course the trust is nowhere near 100%, but if you have a healthy testing process (e2e, validating different browsers, or whatever is appropriate for your environment), then what's your trust in human developer+review? Because mine is nowhere near 100% either.

In practice there are places where I extremely don't care about the code and never wanted it anyway, places where I'll read the code to check the design or just in case, and places which agents are not allowed to touch (medical billing rules for example).

I don't read the code my LLM produces unless I am investigating the code. I actually don't know Kotlin, or React.

My version of "code review" is "test failure investigation" and I have a hard rule in my repos that agents never modify existing tests while they're implementing features. This means that when I run the tests after they do a bunch of stuff, I see all the tests break. Mostly they're stale assertions and we patch them up. Sometimes they're regressions and we patch those up, and sometimes I notice something dumb and dive deep into a facet of the architecture that can be improved, spend some time exploring it then get the agent to implement.

I think it's a better approach than trying to read everything and catch bugs or improve quality because you wind up focusing the things that actually matter in the real world rather than the things you think might matter.

This is how I've always approached working with offshore devs too. Focus on testing for quality control, not "code quality". After all, you're going to look at the code you wrote 5 years ago and think it's shit anyway right? So all your code is shit.

Regarding "lack of understanding", here's a recent anecdote: I had a bug in a production (but relatively new) system. The customer was texting me saying that they couldn't scan a QR code because it kept "skipping and glitching". They sent me a short video. I described the problem to the agent and it figured out WAY faster than I would have been able to that the customer's clock was set incorrectly. They turned on network time and bingo bango, the thing worked straight away.

I don't thing "comprehension debt" matters at all, because if you want to know something about the code you ask the agent. I can't remember how anything works after 12 months anyway, so I would frequently have to spend ages grepping my own code when a customer came back and asked me to change something in a system we hadn't touched since last year. Asking an agent the same thing takes minutes and is way more accurate (and fun!)

Regarding "lack of understanding", here's a recent anecdote: I had a bug in a production (but relatively new) system. The customer was texting me saying that they couldn't scan a QR code because it kept "skipping and glitching". They sent me a short video. I described the problem to the agent and it figured out WAY faster than I would have been able to that the customer's clock was set incorrectly. They turned on network time and bingo bango, the thing worked straight away.

That only describes a happy path though -- I also had many instances where there's an issue and just describing it to an agent immediately identifies a fix and it all goes faster compared to me having to "load up" the flow of codebase into my brain first. But I also still have instances where it thinks it identifies an issue correctly, spits a fix which doesn't work and looks wrong. You point out that it does not make sense because of X, it agrees and spits out a new fix, which is also wrong and you start out on these back and forth wild goose chases, at this point I usually give up and do it the old fashioned way by understanding what is actually happening. If it is within an agent loop, there may be no back-and-forth to waste your time but then you pay with wasted tokens when it will eventually gives up or you stop it.

I don't thing "comprehension debt" matters at all, because if you want to know something about the code you ask the agent. I can't remember how anything works after 12 months anyway, so I would frequently have to spend ages grepping my own code when a customer came back and asked me to change something in a system we hadn't touched since last year. Asking an agent the same thing takes minutes and is way more accurate (and fun!)

I would question the last part. In my mind the more you let go of control over your codebase the more likely that it will drift way from a place where it is still comprehensible to you, and also your comprehension skills atrophy, and with that, your ability to ask good questions and to prod your agent in a correct directions weakens, leading to more wild goose chases and burned tokens. This is all keeping in mind that for throw away or small applications, maintainability is not that of important of a value so this doesn't affect all codebases.

I dunno, I've built a production billing system for my small telecom company, a first version of a Multiplatform app with some novel technical features, and multiple internal tools for a company I work for, which replace a bunch of tools that were strung together using various off the shelf tools. I've been working with agents for about a year. I haven't noticed any cognitive or comprehension decline. I've built things that would have taken a team of offshore devs multiple months on my own in 4 - 6 weeks, including my own coding agent harness which runs an LLM gateway and has mobile, desktop and web apps which is now in use by non-technical colleagues to build and maintain apps on the same platform.

I don't know any more about KMP, Kotlin, Compose, Bash or React than I did a year ago. I'm not that familiar with any of those technologies (well, I am pretty familiar with bash but not to the level at which it's coded by agents), and I have never run into a situation where I felt like it would be better or faster for me to learn them and go hunting through the code to find some problem or other.

Maybe I'm heading towards a cliff somewhere in the future, but based on my experience of building software for 20+ years I'm not feeling anything but optimism so far.

It is quite irrelevant to examine political opinions or if the conference turned into a Jonestown cult etc.

The only thing that matters in AI is to examine the flow of money. DHH is a Shopify board member and surely got Shopify stock.

Additionally, his Omarchy is sponsored by the following AI boosters (https://omarchy.org/patrons/):

  - Meta Superintelligence Labs
  - DigitalOcean
  - Alibaba Cloud
  - Shopify (Tobi Lütke)
  - Stripe (Collison)
  - Dell (Dell)
  - Cloudflare (Prince)
  - Dropbox (Houston)
  - OpenClaw (Steinberger)
  - Coinbase (Armstrong)

His Fridman promotion was sponsored by Shopify:

https://lexfridman.com/sponsors/ep501-sb

His future is tied to the AI narrative and he sells out stuff he no longer needs like RoR. Anything he says is an advertisement.

As can be seen from that list, DHH is now protected here like Steinberger. Never mention money and funding. Calling DHH a fascist is allowed and encouraged because it distracts from the end goals. But money, hell no!

Calling DHH a fascist is allowed and encouraged because

...it's true, based on his own words.

Two slightly disconnected thoughts:

1. This is why BDFL culture in open source is bad. Because if the BDFL decides to go all in on some completely bizarre mess, all of a sudden there’s massive fork politics.

2. Hey is the marquee product now?? Does anyone actually use Hey? I tried it for a year, and basically found I was paying for the privilege of having a slower, buggier, less feature-rich gmail that can’t even dent the have-a-paid-email-that-doesn’t-exploit-you market (Fastmail and Proton exist, yo).

The only people I know still using Hey are doing so because there's no way to move your address elsewhere. It's a PITA to change your email everywhere (and some unfortunate place don't let you; e.g. email as the login and primary key)

If you cancel, 37signals let you keep your hey.com address and auto forward mail to a new email address. :)

BDFL works great as long as the D remains B.

I already migrated all of my projects off rails, moving to fastapi, due to a combination of DHH's political bs and Ruby's fumbling of progressive typing/type hints. I actually just completed the migration a couple weeks ago.

I'm now doubly-glad since it seems like, indeed, the bdfl has lost both the plot and the B. The fact that Omarchy is also some weird corporate-sponsored AI-pilled linux reskin is further concerning.

In retrospect, his jamming of things like thruster, hotwire, etc etc into the framework and then now basically abandoning them has me grateful I didn't adopt them, even though I thought they seemed pretty well-intended at the time.

If all this is true, why are election apps still popular instead of native?

Why are high level managed languages still being used?

For that matter, why aren’t LLMs generating everything in wasm or native assembly?

People are reading into moving to native apps for each OS for an email app as a move away from Rails or that Rails is dead. The hot-take headline could be "Web applications are dead!" Rails, Django, Laravel, HTMLX, every one of them is in the same spot Rails is in.

We as an industry have been abusing HTTP and HTML for 2+ decades now by building web apps that were traditionally installed client/server applications or standalone client applications. There was a time in the industry that managing all the OS versions, patches, etc. was extremely labor intensive, hence the move to the web. If the cost of building native apps is near zero, in comparison to before AI, then how many web applications are better suited to client/server apps?

Take everyone's favorite app (sarcasm) - ticket tracking for IT or software work. Back in the day (late 90's) this was an installed app, the UI was extremely responsive and restrictive. People building native apps in Visual Basic didn't have to deal with HTML, CSS, and all the trade-offs of a markup language for an application, they had modules/components they could build for UIs. There wasn't weird DOM hierarchies, a data transform to text, send it over HTTP with auth, protect the web server that is open to anyone on the planet to hack, transform from text to data types, save to a database. The native app had a database driver in it or nearby and you did SQL from the app to your database server.

We can containerize application runtimes now. Look at what 37signals did with ONCE as an example, yes they are Rails apps but they could be anything that reduces IT install time compared to the '90s.

My takeaway from that keynote (watched the whole thing) is we need to re-think everything in software: process, tech stacks, architecture, etc. as the industry moves forward. AI has advanced a lot in what it can do in the last 10 months, it might plateau at some point and become another usable tool, but what it opens up is the ability to do things differently because the cost of creating (and throwing away crap output and re-creating) is very cheap.

The web as an application delivery model is very complicated compared to building small native apps. If your average Joe or Jane is going to be creating apps, I would think the thing to reach for is not web.

"If every product is used by an agent driving a CLI, what’s going to differentiate Basecamp or Fizzy from the cheapest alternative?"

At that point, why even bother with "driving a CLI"? I have a hard time seeing how this all doesn't go away soon. At the current trajectory, I am not seeing a future where software like Basecamp or Fizzy or the cheapest alternative are competitive with "Claude, build a basecamp-style project management tool for my team."

I don't mean to say that thoughtfully built, opinionated software doesn't have intrinsic value, I believe it will always be "better" in certain aspects...I just can't fathom that a market for it will exist in very short order.

I would LOVE to be talked out of this perspective.

Why would you build an app at all? Why wouldn't Claude just be the app itself? You ask it to set up your UI in the web app and you just use Claude for your entire workflow.

We're only a few persistent widgets and a better persistent storage story away from this possibility.

I’m building a language learning application [1]. It uses spaced repetition, built upon FSRS, an open source algorithm.

I’ve spent the last three years tweaking away at this algorithm. There are so many little details that have had to come together to make it an enjoyable experience. For example, take the one problem of balancing multiple language: What is the best way to balance multiple languages? How should you switch between them, and how often? What happens if you are over performing in one language and underperforming in another? What happens if you have more reviews in one language than another that isn’t in line with your priorities? How do you deal with competing learning speeds and language priorities? Spiky review burdens? What happens when you change your language priorities?

This is probably the most trivial part of the algorithm, and it took years of trial and error and dozens of iterations to get it to feel right. It requires knowing about SRS, the FSRS algorithm, language learning principles, and even then tons of experimentation, trial and error, and hundreds of days of daily usage.

I’ve asked LLMs every step of the way what to do. I’ve probably taken <1% of the advice I was given. Just asking an LLM “build an SRS app that balances multiple languages” would produce a result, but one that would definitely be terrible to use, and probably would end up slowing you down, not speeding you up. Explaining to it any of the issues that you would come across when using it will likely suggest to changes that will only make things worse, based on the thousands of terrible ideas I’ve seen confidently produced.

The hard part of a product is not the idea, but the experience of using it. The valueable work is normally not in the big feature specs, but the hundreds of little paper cuts that have all been smoothed over. The time saved is not because you don’t have to code it, but is from not having to become an expert in several different fields.

[1] https://phrasing.app

The hard part of a product is not the idea, but the experience of using it.

solid

I’d love to stop paying attention to him, but I build applications with Rails, so his actions affect me and my clients.

DHH purpose-built a tool so this guy could build a career on it. The guy delightfully uses the tool to get rich. And he wants to hate DHH--probably does--but no, DHH *owes him more*. And has lots of advice for DHH about how to manage his own creation.

The entitlement in 2026 is so wildly off the charts.

Why does the author know better than DHH how to lead rails? How does the author know how the community will react to the keynote?

The problem is that he stood up at Rails World and told everyone that he was moving his product off Rails

Maybe the author doesn't understand the use-case for rails? I think DHH does. With enough success, there comes a day that you move your product off of rails.

Rails is great for agentic coding, which DHH also said.

Yeah, the author's opinion would be way more justified if Rails were an open-source project with thousands of contributors and not just the hard work of DHH himself in total isolation.

The author's opinion about the direction of rails would be more justified if he was a contributor, which he doesn't appear to be.

But no, you mischaracterize my position, which is that his opinion would be way more justified if he was critiquing someone who had led a failure, or if he had some really valuable insight that DHH didn't have, or if he had led something even more successful than what DHH has managed.

No surprise.

2007-01-20, by David H. creator of Rails:

(15:11:12) DHH: before fastthread we had ~400 restarts/day

(15:11:22) DHH: now we have perhaps 10

(15:11:29) Zed S.: oh nice

(15:11:33) Zed S.: and that's still fastcgi right?

The main Rails application that DHH created required restarting ~400 times/day.

I know this is not exactly a nuanced take, but why would anyone take advice about the future of technology whose contributions are now limited to an opinionated email app? I appreciate that tech is and will change even more, but relegating an entire ecosystem to the dustbin because you're feeling bullish about LLMs seems...premature.

The Ruby on Rails community has always been hard to separate from DHH.

The fact that he went on stage at a Ruby on Rails keynote and talked about his current passions instead of Rails is kind of typical for his style of leadership. The Ruby on Rails project and community were always the DHH show, even though there were years where they tried hard to act like it was an independent community run project now.

This late in the game, I think most RoR fans who are committed enough to attend a RoR conference have aligned themselves with DHH more than RoR, which is why you see some positive responses to a RoR keynote that didn't talk about RoR.

I get the whole “we don’t have to read the code anymore” Schtick from most product devs, and DHH I guess is at his core a builder / product dev whatever.

But the development of something like rails pushed forward the state of the art in ways that LLMs now replicate.

The point being like - someone has to keep writing programming languages and frameworks and libraries. Like - someone has to be thinking what the code looks like for LLMs to have patterns to match against, right?

someone has to be thinking what the code looks like for LLMs to have patterns to match against, right?

Assuming no new paradigms on the hardware side that no longer fit into our current programming models, do they? Rails' claim to fame was eliminating "XML sit-ups" to improve the developer experience, but who cares how many "sit-ups" LLMs need to do?