That's great, but from my experience, 90% of Rubyists I met are working with Rails. "Divorcing" from Rails is therefore absurd, just stuff people say who don't like DHH for one reason or another.

We work with Rails but there is more to programming (and Ruby) than work. Sinatra micro services were a thing for a while. Hanami is decent. But the reason we use Rails is pretty simple…it’s great, easy to onboard developers, it’s battle tested, well maintained and has a massive ecosystem.

I don’t even care that DHH is a Nazi because you know what I can use it for non-Nazi stuff and there’s nothing he can do about it. I get his labour for free. He’s like my little Nazi monkey slave.

this is great example of framing.

my take I use ruby a lot too - DHH might be disagreeable - but the one thing is one bright light i.e Rails ends up dimming the others. so when it cracks - like it did - people go to the next room, even though the current room has enough light.

Sure, but we gotta start somewhere, right? :) What would you find most useful to add next?

Well, the actual comparison from experience.

Hmm, I don’t think sharing my personal experience would be that useful. For one, I’ve only used a handful of these tools long enough to give a meaningful assessment. More importantly, though, these tools evolve so quickly that anything I wrote would likely be outdated almost immediately.

I'd rather give folks an overview over which tools exist and some info about their popularity, price point etc.

Maybe it would be cool to add links to the founder's accounts on X, Youtube etc. where they share new releases and what they're working on...

Thanks for the feedback!

> Good list, but gosh the term "agent orchestrator" is really being diluted endlessly these days.

Yeah, there's a lot happening in this space... but I think those 13 tools which are one the list right now all try to do the same thing - make it easier to run multiple agents (mostly over multiple apps) at the same time. Are there any tools you would add or remove?

> Also, putting Zed and Cursor in the same "freemium" bucket is really unfair...

Sure, the "free" plans of some of the tools are not really comparable, but I think that's out of scope for this list. :)

I added a comment to Cursor in the list. ;)

Really cool to see superpowers adjusted for Rails development!

One question: looking at the Rails conventions stills you added, wouldn't rules with paths be a better match for that: https://code.claude.com/docs/en/memory#organize-rules-with-c...

Hearing people still mention "monkey patching" always makes me chuckle... I haven't "monkey patched" anything in Ruby in > 5 years, and I don't see it in any of the popular libraries/gems anymore either.

Especially when the big difference is that Ruby had proper OO system that allowed patching, when necessary, to be done in much saner way...

whereas the origin of monkey patching seems to by Python with its totally broken magical method names and kitbashed object model.

Module#prepend was introduced in Ruby 2.0, in 2013, which was the solution to monkey patching.

Well, that and Module#refine.

You can pin a gem to a specific version, of course.

`gem "mygem"` installs the latest version. `gem "mygem", "~> 4.0.0"` installs >= 4.0.0 but < 4.1.0, which is what you probably want when using Semantic Versioning, which most gems adhere to, to get the latest patch version. `gem "mygem", "4.0.10"` installs exactly that version.

For 99% of use cases (especially when writing shell scripts) it doesn't matter, just pick the one you know better. Both are nicer than Bash though. :)

Can you give an example? I can't think of a single situation where whitespace matters in Ruby (unless of course you forget to put a space between two commands or something silly).

It's not really a problem in practice (and I love Ruby), but it's still wild to me that they made the parser do this:

    $ irb
    irb(main):001:0> def foo(x=70) = x
    => :foo
    irb(main):002:0> i = 2
    => 2
    irb(main):003:0> foo / 5/i
    => 7
    irb(main):004:0> foo /5/i
    => /5/i

if foo is a method then

`foo + bar` and `foo+bar` are `foo()+bar`, but `foo +bar` is `foo(+bar)`

ternary ? : also has some interesting whitespace dependent mixups with symbols, but I cannot remember what. I think that parser has many gotchas like that, but they are really really rare to bite you, because ruby's magic follows human intuition as much as possible.

What do you mean by "broken gems"?

Either dependency issues with other gems, or gems that break due to some sort of library in the OS. If you pin all of your versions, and use it in one place, that's less of an issue, but many scripts are designed to have some level of portability (even if it's to a new instance of the server)

In my experience, Bundler has improved a lot with regard to resolving dependency issues over the years. And OS libs are only really depended on by a few gems, no? 99% of them don't use FFI or call OS libs.

Moreover, how often do you really move a script to a completely different OS, where you don't know which OS libs are installed? And wouldn't those missing OS libs also be a problem when writing the script in Bash or any other language?