Latest / The Ruby AI Podcast / Running Self-Hosted Models with Ruby and Chris Hasinski

Transcript

Running Self-Hosted Models with Ruby and Chris Hasinski · The Ruby AI Podcast

• 0:00
  SPEAKER_01: Hey everybody, welcome to another episode of the Ruby Ad Podcast.
• 0:04
  SPEAKER_01: I'm one of your co-hosts today, Valentino Sol, joined with Joe.
• 0:09
  SPEAKER_01: Hey everybody, welcome to the podcast.
• 0:12
  SPEAKER_02: Today we're joined by Chris Zinski, Rubyist open source author, frequent speaker, and we're going to talk about self-hosted models and probably a whole bunch of other topics.
• 0:24
  SPEAKER_02: Chris, welcome to the show.
• 0:25
  SPEAKER_02: Thanks for having me.
• 0:27
  SPEAKER_02: So, Chris, let me ask you just from the start, as we jump in here, why should we host our models ourselves?
• 0:36
  SPEAKER_00: There are many reasons to host a model yourself.
• 0:39
  SPEAKER_00: One that is I like to present that is really non-obvious is that if you self-host a model, you can test it again and again with the same model.
• 0:48
  SPEAKER_00: You don't get this guarantee with any provider-hosted model because they can change them any way they want.
• 0:53
  SPEAKER_00: And anytime they want to do it.
• 0:54
  SPEAKER_02: They often do, right?
• 0:55
  SPEAKER_00: Yeah, they often do, especially with things like GPT-5, which is a router model, you don't really get to know what's responding to your request underneath.
• 1:03
  SPEAKER_00: So that's one example.
• 1:05
  SPEAKER_00: The other one is you pay for the hardware, not for the tokens.
• 1:08
  SPEAKER_00: So some classes of problems suddenly become viable because you don't pay per usage.
• 1:14
  SPEAKER_00: You have like all the users you want.
• 1:16
  SPEAKER_00: And hosting something cheap that has some real AI power, like a Mac mainly in cloud, gives you idea of the ability to do something like voice recognition and live streaming.
• 1:29
  SPEAKER_02: And what would you say to so the counter-argument for self-hosting, I think, is that it could be very slow, right?
• 1:38
  SPEAKER_02: If you're running it on your own hardware, and that the models that you're able to host are not as good or they're not up to the same standards that the premier off-the-shelf models are.
• 1:50
  SPEAKER_02: What would you say to that?
• 1:51
  SPEAKER_00: Yeah, you're absolutely right.
• 1:53
  SPEAKER_00: First of all, if you run something your own, it's not subsidized.
• 1:56
  SPEAKER_00: If you're running something with OpenAI and Tropic, they pretty much pay for the tokens.
• 2:00
  SPEAKER_00: They are not making money on that.
• 2:02
  SPEAKER_00: So you'll get the worst quality.
• 2:04
  SPEAKER_00: But at the same time, you get the guarantee that it will work over time.
• 2:07
  SPEAKER_00: And also you get to pick a model.
• 2:09
  SPEAKER_00: You can fine-tune something, you can train something yourself.
• 2:12
  SPEAKER_00: It doesn't have to be an LLM.
• 2:14
  SPEAKER_00: Maybe some different solution work.
• 2:16
  SPEAKER_00: You can very easily switch those models and you can find something on Heidenface that works better than whatever Entropic provides for two-calling models.
• 2:24
  SPEAKER_00: So I think that there's quite a lot of benefit of still using self-hosted models, even though prototyping with something from Anthropic or OpenAI is definitely easier.
• 2:34
  SPEAKER_00: And you don't have to pick one, you can mix and match.
• 2:37
  SPEAKER_00: And even if you start with something from OpenAI, maybe you want to use, I don't know, an embedding model that will be self-hosting.
• 2:45
  SPEAKER_00: There is no point of doing something like calling OpenAI just to embed, I don't know, a million images or a million PDFs.
• 2:52
  SPEAKER_00: It will be very expensive and you don't really care about the latency and all this stuff.
• 2:57
  SPEAKER_00: You can do it offline on your own hardware.
• 3:00
  SPEAKER_02: Yeah, I like that.
• 3:01
  SPEAKER_02: And maybe we want to dig into that for a moment because my understanding of your work and your talks, you're not just about text, right?
• 3:08
  SPEAKER_02: You do a lot of work with images, for example, and other kinds of content.
• 3:12
  SPEAKER_02: So do you want to tell us a little bit about that?
• 3:14
  SPEAKER_00: Yeah, I can give you a little bit of a background.
• 3:16
  SPEAKER_00: So I actually started my career with machine learning many, many years ago at D UC Davis.
• 3:21
  SPEAKER_00: I was working in bioinformatics department and we were doing protein folding.
• 3:26
  SPEAKER_00: And AI literally took my job because protein folding got solved by AI many years later.
• 3:32
  SPEAKER_00: But still, it was interesting to see something that, like a problem that was going on for like 40 or 50 years, and that we tried to apply some classical machine learning to and got solved in the recent wave of AI.
• 3:45
  SPEAKER_00: So I've been working with classical machine learning here and there.
• 3:48
  SPEAKER_00: I never thought of myself as a machine learning or AI engineer.
• 3:52
  SPEAKER_00: Most of the stuff I worked on was performance or web applications, but I had like a AI or machine learning projects here and there.
• 4:00
  SPEAKER_00: I did something like transaction capitalization, nudity detection, recommendation systems, quite a lot of like small AI or machine learning projects over time.
• 4:11
  SPEAKER_00: Suddenly it became popular again.
• 4:13
  SPEAKER_00: And right now you get this big wave of AI.
• 4:16
  SPEAKER_00: And most of it is LLMs, but you also get stuff like vector databases.
• 4:21
  SPEAKER_03: Yeah.
• 4:21
  SPEAKER_00: You get stuff like image recognition.
• 4:24
  SPEAKER_00: And some of it can be reapplied.
• 4:26
  SPEAKER_00: Like, for example, if you do something like image recognition, it's not only finding images.
• 4:30
  SPEAKER_00: I did a workshop on that, but you can also use the same principles to be content moderation.
• 4:36
  SPEAKER_00: If, for example, you know that you don't want to have Lego bricks in your image database because those are copyrighted and you can't really use them, then you basically find some examples of Lego bricks.
• 4:50
  SPEAKER_00: You put embeddings for those in the database, and then you compare newly added images to the images of Lego bricks that you already have, and now you have a content moderation system.
• 4:59
  SPEAKER_00: So definitely not only LLMs.
• 5:01
  SPEAKER_00: I've worked with quite a lot of different models.
• 5:05
  SPEAKER_00: I even train a little bit of, I wouldn't say big solutions, but good enough to actually be applied to production for some stuff.
• 5:14
  SPEAKER_02: Like what, for example?
• 5:15
  SPEAKER_02: The training I'm interested in.
• 5:17
  SPEAKER_00: For example, some router models, stuff that will hand off a query to one of several different agents that can respond to it.
• 5:27
  SPEAKER_00: I also did some work on it's actually a project by done by Irina Nazarova.
• 5:33
  SPEAKER_00: She does she wants to do this emotion recognition from speech, right?
• 5:37
  SPEAKER_00: So what happened is that she wants to take the talk of a speaker from the microphone and make the lights at the venue react to the tone of the voice they are speaking.
• 5:50
  SPEAKER_00: Like, for example, interesting.
• 5:52
  SPEAKER_00: If they will be happy, it will be like green, or if they will be angry, it will be red or something.
• 5:57
  SPEAKER_00: So I started with like some models that they're on hiking face because that's the easiest part.
• 6:03
  SPEAKER_00: And I did some experiments.
• 6:06
  SPEAKER_00: It was okay, but it wasn't the best quality.
• 6:10
  SPEAKER_00: A colleague of mine sent me his own model because there is like ongoing competition for basically this problem here in Poland.
• 6:16
  SPEAKER_00: And we have a lot of AI startups and AI competitions in Poland.
• 6:21
  SPEAKER_00: So I just happened to stumble upon something that matches.
• 6:24
  SPEAKER_00: And he sent me something that is much better.
• 6:26
  SPEAKER_00: And I tried to fine-tune it a little bit on the data that I have, and I think it gives good enough results.
• 6:32
  SPEAKER_00: We'll see at San Francisco Ruby if they all use it.
• 6:35
  SPEAKER_02: Oh, yeah, that's interesting.
• 6:36
  SPEAKER_02: So this could be rolled out at SF Ruby.
• 6:39
  SPEAKER_00: Yeah.
• 6:39
  SPEAKER_00: I also did a few talks about fine-tuning non-self-hosted models, like something that is in cloud, like mostly open AI models.
• 6:48
  SPEAKER_00: And this was mostly to show people that the models aren't really static.
• 6:52
  SPEAKER_00: It's not something that is given and you can't really edit, and you can just call the API and get the result.
• 6:57
  SPEAKER_00: You can actually edit models.
• 6:58
  SPEAKER_00: That's why you need to collect data, you need to clean data and store good data sets on your own from your own stuff, from your own applications.
• 7:07
  SPEAKER_00: Because you can reuse this data.
• 7:09
  SPEAKER_00: If you have, like, for example, I don't know, an agent that picked the wrong tool over and over and over again, and you have those conversations, then you can use this set of data, give it to OpenAI and tell it, okay, the right solution should be this tool.
• 7:23
  SPEAKER_00: And if you have like a big enough set of those, you can fine-tune the model to pick the correct tool.
• 7:29
  SPEAKER_00: So I don't really want to think of most of the developers right now in AI space, they think a model is something that Entropic or OpenAI or Google gives us.
• 7:38
  SPEAKER_00: And it's something that's just given.
• 7:40
  SPEAKER_00: And the only way you can influence it is to give it a different context.
• 7:44
  SPEAKER_00: But you can actually edit the model itself, at least in most cases.
• 7:48
  SPEAKER_02: Well, so uh I'm curious about this with editing a model or with fine-tuning or with both.
• 7:54
  SPEAKER_02: Is it much harder to do with a model that is built on massive, massive amounts of data like the OpenAI or anthropic models?
• 8:02
  SPEAKER_00: It kind of depends.
• 8:04
  SPEAKER_00: It's very difficult to add new knowledge to the model, but it's very easy to change the format that it outputs.
• 8:09
  SPEAKER_00: Like, for example, if you want to have a shorter markdown, you can train a model to do fewer tokens, like removing extra spaces and moving extra padding in tables.
• 8:21
  SPEAKER_00: But it's quite difficult to add new knowledge to the model.
• 8:25
  SPEAKER_00: The opposite is true of embedding models.
• 8:27
  SPEAKER_00: For example, if you have a clip, do you know clip?
• 8:30
  SPEAKER_00: I do, yeah.
• 8:31
  SPEAKER_00: Yeah, so clip is something that has like so many different variants, so many different fine-tuning, so many different versions.
• 8:39
  SPEAKER_00: And I've stumbled upon an issue with original clip some time ago.
• 8:44
  SPEAKER_00: It doesn't recognize items that were made after 2021 because that's the knowledge cutoff for that model.
• 8:51
  SPEAKER_00: So if you want to, for example, spot an image of a new iPhone or a Cybertruck, it won't be able to recognize those because those things were made after 2021.
• 9:01
  SPEAKER_00: Right.
• 9:01
  SPEAKER_00: But you can quite easily find like 500 images of a Cybertruck and just fine-tune the model to recognize the new item.
• 9:09
  SPEAKER_00: So you can actually edit those locally, and you can have a model that is vastly more capable in the your specific domain.
• 9:20
  SPEAKER_02: Yeah, that is interesting and very useful.
• 9:23
  SPEAKER_02: With respect to clip, now you built a clip in Ruby pipeline, right?
• 9:28
  SPEAKER_00: I mean, you Yeah, that's something that I actually used in a personal project, then a workshop, then a client project.
• 9:35
  SPEAKER_00: And I decided, yeah, I'm not writing this thing the third time.
• 9:38
  SPEAKER_00: I need a gem.
• 9:40
  SPEAKER_02: So tell us a little bit about that.
• 9:42
  SPEAKER_00: So the original idea was that there was this project that basically used keyword space search.
• 9:48
  SPEAKER_00: And this works pretty well if you have labeled images, but the user was labeling those images, which means that the labels were pretty much terrible.
• 9:57
  SPEAKER_00: And the standard approach for this kind of problem is to basically send those images to OpenAI and tell them, like, I need to know what's on this image, I need to have a set of tags, I need to have some description.
• 10:10
  SPEAKER_00: And this works pretty well, but you get like two layers of abstraction because if you do keyword search on those descriptions, you get a keyword search on a description that was created by something that looked at the model.
• 10:21
  SPEAKER_00: And you can basically short circuit it and do like a direct text-to-image comparison using clip.
• 10:29
  SPEAKER_00: But at the same time, designed was multilingual.
• 10:32
  SPEAKER_00: So if somebody looks for a cat or a dog in Spanish, it still needs to work, right?
• 10:39
  SPEAKER_00: So there are some variants of clip that are multilingual, they vectorize into the same latent space as the regular clip.
• 10:47
  SPEAKER_00: So you can basically use regular clip for images, but you use different model for text, and they will still give you vectors that will match if there is a correlation between those images and this text.
• 10:59
  SPEAKER_00: So I basically packaged this into a gem and it got like 14 stars, which is most my most popular open source project yet.
• 11:06
  SPEAKER_00: Excellent.
• 11:06
  SPEAKER_00: Congratulations.
• 11:09
  SPEAKER_00: Yeah, that's the thing that I was surprised about.
• 11:11
  SPEAKER_00: Like Justin recommended me for this podcast, and he runs ActiveAgent, and he mentioned me uh during the talk like once or twice.
• 11:20
  SPEAKER_03: Yeah.
• 11:20
  SPEAKER_00: I don't really have that many open source projects on well, I don't even have a popular open source project.
• 11:26
  SPEAKER_00: I'm just a guy who visits conferences and discords and talks about AI.
• 11:29
  SPEAKER_02: You should know that on this show we've got a community of people that are fans of people that are doing great work, great talks.
• 11:37
  SPEAKER_02: So, you know, he knows about you probably because of the talks, and because just knowing Justin, he knows all of these other tools.
• 11:42
  SPEAKER_02: I'm sure he's checked this out.
• 11:44
  SPEAKER_02: He might be one of the 14 stars.
• 11:46
  SPEAKER_00: Yeah, and we are both fans of Andrew Kane.
• 11:49
  SPEAKER_02: So Yes.
• 11:50
  SPEAKER_02: Yeah, that name also comes up a lot.
• 11:52
  SPEAKER_02: And we need to pull him out of his open source work for an hour so he can come on the show with us.
• 11:56
  SPEAKER_00: I've heard here's a real person because we have a bet if he's a real person or not.
• 12:00
  SPEAKER_00: Like nobody can meet 16 gems.
• 12:02
  SPEAKER_00: It's incredible.
• 12:04
  SPEAKER_00: Irina told me that she managed to meet him in real life.
• 12:07
  SPEAKER_00: So he's definitely real.
• 12:09
  SPEAKER_02: All right, then I'll believe it.
• 12:10
  SPEAKER_02: I'll believe it if Irina says it's true.
• 12:12
  SPEAKER_02: So I'm curious.
• 12:14
  SPEAKER_02: So you studied at UC Davis, you have this background, you've done a lot of machine learning and AI projects.
• 12:20
  SPEAKER_02: What I've seen from you a lot is you're very proudly like, hey, there's no Python in this.
• 12:25
  SPEAKER_02: This is a Ruby application, right?
• 12:27
  SPEAKER_02: And what made you, how did you or when did you become a Rubyist?
• 12:32
  SPEAKER_02: And why is it important to you that these tools exist in the Ruby world?
• 12:37
  SPEAKER_00: That is a very interesting story, to be honest.
• 12:39
  SPEAKER_00: I've been doing Ruby for 11 years, and my first Ruby project that I did commercially, I didn't know Ruby at all.
• 12:46
  SPEAKER_00: They told me there is a contract.
• 12:48
  SPEAKER_00: If you can learn Ruby over the weekend, we would like to have you in this project.
• 12:54
  SPEAKER_00: There is Rails Girls coming up.
• 12:56
  SPEAKER_00: I will sign up as a mentor and I will have extra motivation.
• 12:59
  SPEAKER_00: So I did Rails Girls as a mentor, and then I started Ruby work the following Monday.
• 13:06
  SPEAKER_00: I've been programming in like seven or eight different languages at that point.
• 13:11
  SPEAKER_00: And Ruby isn't that difficult, especially if you know Java, Python, some PHP, some JavaScript.
• 13:18
  SPEAKER_00: Like it's basically the same principles.
• 13:20
  SPEAKER_00: And you can see Rails spreading out to other languages, so you can see those patterns over and over again.
• 13:27
  SPEAKER_00: And the killer feature for Ruby is still remote work, great remote contracts, and just the ability to work remotely from anywhere and find something interesting in different parts of the world.
• 13:39
  SPEAKER_00: So I started doing Ruby more and more.
• 13:42
  SPEAKER_00: I even did a little bit of a machine learning at that particular project because we did banking transaction categorization, which was interesting.
• 13:50
  SPEAKER_00: And back then Ruby didn't have any ML libraries, so we had to write some algorithms for scratch, mostly classification and clustering.
• 13:59
  SPEAKER_00: So I started Ruby working with Ruby Group more and more.
• 14:02
  SPEAKER_00: I've met Mats at one conference.
• 14:04
  SPEAKER_00: I speak a little bit Japanese, so I met him and I introduced myself in Japanese, and he was so happy that somebody at the conference was at least two words in Japan.
• 14:13
  SPEAKER_00: And since then I've been doing group mostly Ruby exclusively.
• 14:18
  SPEAKER_00: And I got back to Python when I actually wanted to do a little bit of a machine learning project.
• 14:24
  SPEAKER_00: I don't can't remember what it was exactly, but it was something involving PyTorch.
• 14:31
  SPEAKER_00: And I discovered that there is already an ecosystem, of course, done by Andrew Kane, like everything in the space.
• 14:39
  SPEAKER_00: And I converted the model from PyTorch to Onyx.
• 14:43
  SPEAKER_00: You guys know Onyx, you already talked about this.
• 14:45
  SPEAKER_00: And it just worked like immediately.
• 14:48
  SPEAKER_00: There was nothing to be changed.
• 14:51
  SPEAKER_00: So you can basically just take the Python code.
• 14:55
  SPEAKER_00: If you squint hard enough, Python looks like Ruby.
• 14:57
  SPEAKER_00: I when I go to AI conferences, I usually show them Ruby code and tell them squint hard enough, it will look like Python.
• 15:03
  SPEAKER_02: Yeah, exactly.
• 15:04
  SPEAKER_02: You gotta go the other way.
• 15:05
  SPEAKER_00: Yeah.
• 15:06
  SPEAKER_00: So I think that you can do quite a lot of machine learning in AI just with Ruby.
• 15:11
  SPEAKER_00: There are some missing parts.
• 15:12
  SPEAKER_00: We don't have a good library for training models, especially distributed training.
• 15:17
  SPEAKER_00: But here's the thing: training you usually do rarely on some initial stages, and then you basically use those models.
• 15:27
  SPEAKER_00: So you can train something in Python, which is usually a very short script, and then you can run it in Ruby inside of a nice Rails applications, mobile application which will be recognized by any Ruby developer.
• 15:40
  SPEAKER_00: So I think that if I'm writing something porting code from Python to Ruby, it's immediately useful to somebody who's a Rubyist, even though they don't you can't modify the model without touching some Python, but the value is still there.
• 15:57
  SPEAKER_00: So I try to port a lot of code from Python to Ruby basically.
• 16:00
  SPEAKER_02: Yeah, and we appreciate it.
• 16:02
  SPEAKER_02: I'm curious though, to go back to what you were saying.
• 16:05
  SPEAKER_02: What's the library, what's the part of Python that supports distributed training that Ruby lacks?
• 16:12
  SPEAKER_00: When it comes to distributed training, the part that is missing the most is the equivalent of Python DDP, which is a distributed training library.
• 16:20
  SPEAKER_00: We don't really have a good implementation, at least fast implementation of transformer training like GPT.
• 16:28
  SPEAKER_00: You can even take a look at the existing training code for training, which is like a thing that the Andrew Carpeti did a while back.
• 16:35
  SPEAKER_00: It was called Nano GPT, and it basically allows you to go to train a full GPT-2 on your own hardware or in cloud.
• 16:44
  SPEAKER_00: The code is terrible.
• 16:46
  SPEAKER_00: Andrew Carpeti tends to use global variables everywhere, and that's his way of configuring stuff.
• 16:51
  SPEAKER_00: But at the same time, it shows you how to train a full GPT-2 level model, which is kind of amazing.
• 16:58
  SPEAKER_00: We don't really have any equivalent of that.
• 17:00
  SPEAKER_00: And I never tried porting it, but I'm quite sure that you'll be missing a few libraries.
• 17:06
  SPEAKER_02: Right.
• 17:06
  SPEAKER_00: Same goes for tiny things that are useful but not strictly necessary.
• 17:12
  SPEAKER_00: For example, TorchRB can read any PyTorch model, but some of them will fail because of some data structures used in Python.
• 17:19
  SPEAKER_00: So you have to probably load it in PyTorch, not in TorchRB, and then export it to Onyx because it will work this way.
• 17:28
  SPEAKER_02: I see.
• 17:29
  SPEAKER_00: Tokenizers, like we have a great tokenizer gem, once again done by Andrew Kane.
• 17:34
  SPEAKER_00: But for Ruby, you have those uh automatic model recognition and tokenizer recognition and then whatever slate recognition you need for those models.
• 17:44
  SPEAKER_00: So basically, any model that you download from Hugging Face is just like one liner to run it.
• 17:49
  SPEAKER_00: We don't have this luxury yet.
• 17:51
  SPEAKER_00: So if we can't run it with one liner, very little people, or few people are interested in training those models or fine-tuning them.
• 18:00
  SPEAKER_02: Right.
• 18:01
  SPEAKER_02: So that's good to know.
• 18:03
  SPEAKER_02: With respect to the models themselves, and you made reference to Hugging Face.
• 18:09
  SPEAKER_02: Valentino, when he gets here, could talk all day about Hugging Face.
• 18:13
  SPEAKER_02: I'm always a little bit curious.
• 18:14
  SPEAKER_02: This is me, and I'm not in the weeds as often as you guys are, but going on to Hugging Face, I'm like, okay, there's millions of choices here.
• 18:22
  SPEAKER_02: How do I decide what I need for my particular task?
• 18:26
  SPEAKER_02: And so do you have any standards where you're saying, okay, depending on the task, the size, how do I decide what I'm doing?
• 18:33
  SPEAKER_00: I got this question after every single talk I did on running the models offline.
• 18:38
  SPEAKER_00: And my usual go-to question is, I do not browse hagging face manually.
• 18:42
  SPEAKER_00: Okay.
• 18:42
  SPEAKER_00: I ask Claude to do it for me.
• 18:44
  SPEAKER_02: Okay.
• 18:45
  SPEAKER_00: Because most of those problems, they have very odd and quirky names.
• 18:48
  SPEAKER_00: Like speech emotion recognition is ER.
• 18:52
  SPEAKER_00: Right.
• 18:53
  SPEAKER_02: How am I gonna find that?
• 18:54
  SPEAKER_02: Yeah.
• 18:55
  SPEAKER_00: Yeah, like you wouldn't guess from just the name of the model that SER is speech emotion recognition.
• 19:00
  SPEAKER_02: Right.
• 19:01
  SPEAKER_00: So what you do is you go to ChatGPT or Claude, describe the problem a little bit, connect an MCP to browse, or even if you have like a desktop thing, it can browse the web on its own.
• 19:12
  SPEAKER_00: I mean, find me some hugging phase models that will work with this problem.
• 19:17
  SPEAKER_00: And that's a very good starting point.
• 19:19
  SPEAKER_00: Like you don't really need to dive that deep into machine learning and AI to be able to find a matching model.
• 19:27
  SPEAKER_00: I have this example from Ruby Builder's Discord.
• 19:32
  SPEAKER_00: There was one guy, I can't remember his name, but he joined and he said that he's using Claude to find if the document is rotated or not.
• 19:40
  SPEAKER_00: Because if it's rotated, then you can't use it for OCR, you have to rotate it back.
• 19:45
  SPEAKER_00: Right.
• 19:46
  SPEAKER_00: And using Claud is a very big machinery just to process an image and tell if the thing on the image is rotated or not.
• 19:55
  SPEAKER_00: And there is like a one megabyte model that does exactly that in Onyx.
• 19:59
  SPEAKER_00: It's super fast, and it just gives you the answer if it's rotated or not.
• 20:03
  SPEAKER_00: You can run it as a sidekick job in the background, and it'll be plenty of fast.
• 20:07
  SPEAKER_00: Wow.
• 20:08
  SPEAKER_00: So I wouldn't be able to find this model easily, but ChatGPT can.
• 20:14
  SPEAKER_02: Yeah, yeah, exactly.
• 20:16
  SPEAKER_02: Let me ask you another question, and maybe you get this one as well often.
• 20:20
  SPEAKER_02: I love Claude Code.
• 20:22
  SPEAKER_02: A lot of people love Claude Code or Codex, right?
• 20:24
  SPEAKER_02: Because it helps us to do a lot of code development fast, but it costs a lot of money.
• 20:29
  SPEAKER_02: It could cost a couple hundred dollars a week.
• 20:31
  SPEAKER_02: I guess let me ask you this.
• 20:33
  SPEAKER_02: You have such knowledge of this space.
• 20:36
  SPEAKER_02: Do you use it as well?
• 20:38
  SPEAKER_02: Or do you use some local model that you have trained to perfection?
• 20:43
  SPEAKER_00: I have a cloud code subscription, and that's my go-to.
• 20:47
  SPEAKER_00: I don't think there is anything that will work to the same level as cloud code right now.
• 20:52
  SPEAKER_00: You have to remember that most of those models need some training data, and you have much more training data from companies that actually distribute those tools.
• 21:00
  SPEAKER_00: So it will be a while since we have something that can compete with those models.
• 21:05
  SPEAKER_00: DeepSeag is pretty cool, but spending$10,000 on hardware and the model might change next year and it will not fit to your hardware.
• 21:14
  SPEAKER_00: I don't think it's a wise investment.
• 21:16
  SPEAKER_00: So right now, I don't think you have anything that will work with the same pricing and the same scale as Cloud Code or Codex.
• 21:26
  SPEAKER_00: Things might change as those companies stop subsidizing those subscriptions because, as you probably know, if you're paying$200 a month for cloud code, this does not cover your costs.
• 21:39
  SPEAKER_00: And companies pay much more because they are built by the token, not flat subscription prices.
• 21:45
  SPEAKER_00: So I think that there isn't anything for coding specifically that can work.
• 21:50
  SPEAKER_00: You can try simple scripts with Llama or Deep Seek or some other model, and it will work.
• 21:56
  SPEAKER_00: But when you get to like a big project that has a lot of context.
• 22:00
  SPEAKER_00: Even if you use some great tools like Ader or Open Code, there is still nothing that will work as great as Sonic Cloud Sonnet or GPT-5.
• 22:11
  SPEAKER_02: Yeah.
• 22:12
  SPEAKER_00: Sorry.
• 22:13
  SPEAKER_02: That's okay.
• 22:14
  SPEAKER_02: That's okay.
• 22:14
  SPEAKER_02: I'm just channeling our listeners who I'm sure have this question in mind.
• 22:18
  SPEAKER_02: Another thing that I think is probably helpful for folks.
• 22:21
  SPEAKER_02: So let's say going back to okay, I've chosen a model.
• 22:24
  SPEAKER_02: I've had Anthropic or I've had uh ChatGPT help me to select the model from Hugging Face, and I'm using this in a Ruby application.
• 22:33
  SPEAKER_02: So what do I do next?
• 22:35
  SPEAKER_02: What's the deploy pattern for leveraging a model?
• 22:38
  SPEAKER_02: What's the infrastructure?
• 22:40
  SPEAKER_02: You know, what am I using?
• 22:42
  SPEAKER_00: Here is an interesting thing that I also did during I think the Paris RB.
• 22:47
  SPEAKER_00: I did uh talk about using AI offline.
• 22:50
  SPEAKER_00: I basically took somebody else's presentation.
• 22:53
  SPEAKER_00: It was Pavel Strakowski.
• 22:55
  SPEAKER_00: He was a speaker at Rails World.
• 22:57
  SPEAKER_00: He had this Rails application in which you basically have an animated dog and you talk to the Rails application.
• 23:04
  SPEAKER_00: It sends your voice to Whisper to false transcription, takes the transcription, sends it to OpenAI for a tool call, and the dog will react to your command.
• 23:16
  SPEAKER_00: So basically, you can set something like dog name was gem, if I'm not mistaken.
• 23:20
  SPEAKER_00: So gemsit, and you get an animation of gemsiting in like 12 seconds or so because it's not very fast.
• 23:27
  SPEAKER_00: So I just replaced Whisper call to Whisper CPP, and I replaced the OpenAI call to OLAMA with Llama 3.2.
• 23:39
  SPEAKER_00: And I did exactly his slide from the presentation, like the live demo, but first going disabling Wi-Fi on the laptop.
• 23:47
  SPEAKER_02: Uh-huh.
• 23:48
  SPEAKER_02: Yeah.
• 23:48
  SPEAKER_00: So you can replace the code that you have quite easily, but there is a little bit of work finding a model that will have comparable quality, especially for it given a particular use case.
• 24:01
  SPEAKER_00: If you have something that generates like a end-user visible text, especially a lot of it, you might not find anything that will generate the same quality of writing.
• 24:12
  SPEAKER_00: But if you're mostly doing tool calls and you want to like have an agent that picks one of the several options based on the text provided, you can just download whatever current llama is, the one that will fit on the server with your budget or even on your MacBook to just to test it.
• 24:30
  SPEAKER_00: And if the model works, then basically it's a matter of finding a right hosting for it.
• 24:36
  SPEAKER_00: And you get the guarantee of fixed price.
• 24:39
  SPEAKER_00: And you also get the guarantee of the model staying the same and responding the same to the same questions in a couple months.
• 24:47
  SPEAKER_00: And you can also do an even smaller model for testing purposes.
• 24:51
  SPEAKER_00: So if you have like a test suite that depends on LLM, then you can spin up LLM in a Docker.
• 24:56
  SPEAKER_00: There is an Olama Docker, and there is a VLM Docker, which you just give it a model, and you have basically LLM that you can treat the same as you treat Postgres or Redis.
• 25:08
  SPEAKER_00: Something that you can use for local testing or deployment, and it works like a database.
• 25:14
  SPEAKER_00: So basically external service for your LRS application.
• 25:18
  SPEAKER_02: Yeah, that's really interesting.
• 25:19
  SPEAKER_02: We started at the top of the show, you mentioned one of the benefits of using your own model is the ability to test it.
• 25:27
  SPEAKER_02: So let's get into that for a bit.
• 25:30
  SPEAKER_02: What are the kinds of strategies that you use when you are testing a model that now has become more predictable but is still not deterministic?
• 25:42
  SPEAKER_00: Most of the models and custom models, self-hosted models I've used, their specific task was picking the right tool and right parameters.
• 25:51
  SPEAKER_00: So basically, advanced tool calling to do like an agent network.
• 25:55
  SPEAKER_00: The way you do this is you basically have fixed scenarios with some recorded data, especially the failures that you had in the past.
• 26:04
  SPEAKER_00: That's the reason why you want to log every single chat that you have on the model.
• 26:09
  SPEAKER_00: And you put those into tests.
• 26:11
  SPEAKER_00: It doesn't have to be complex, it might be something like a Ruby LM call or activation call that basically gives all the context in one go and expects a given response.
• 26:22
  SPEAKER_00: And you have two things out of that.
• 26:25
  SPEAKER_00: First of all, you have a repeatable and growing library of prompts that you can evaluate.
• 26:32
  SPEAKER_00: And second thing, if you want to change the model, you can run the same thing with the new model and you just get the some kind of certainty, not all of it, because of obviously it's an LM, that it will still pass with a new model that you picked.
• 26:47
  SPEAKER_00: So basically, like with everything in machine learning and AI, you need data, and the algorithms are usually quite easy.
• 26:56
  SPEAKER_02: Now, you've mentioned this before as well.
• 26:59
  SPEAKER_02: The data that you need to be able to store data, clean data, and produce a lot of it.
• 27:05
  SPEAKER_02: Those are also not traditionally tasks that people pick Ruby for, the data engineering tasks.
• 27:12
  SPEAKER_02: Do you prefer to have the cleaning and the storing of data and mining of data done in Ruby?
• 27:19
  SPEAKER_00: Ruby is great for cleaning and storing data.
• 27:21
  SPEAKER_00: Like most of the work that we do actually is data transformation.
• 27:25
  SPEAKER_00: If you think like of a traditional Rails application, so some crowd application with some extra polish on the front end that will give you some well window into a database, right?
• 27:36
  SPEAKER_00: Yeah.
• 27:37
  SPEAKER_00: What we're doing is we're basically relying on the database to do the heavy lifting, and we add some really nice UX or interface on top of it.
• 27:45
  SPEAKER_00: So we are actually really good with this.
• 27:47
  SPEAKER_00: I don't think that the average rule beast will have a problem doing most of the data engineering tasks.
• 27:55
  SPEAKER_00: We have clean models.
• 27:56
  SPEAKER_00: If you look at the any Java application or PHP application, those databases are usually named horribly.
• 28:02
  SPEAKER_00: Yes.
• 28:02
  SPEAKER_00: The fields are super inconsistent, the migrations are terrible.
• 28:06
  SPEAKER_00: We don't really have this problem with Ruby because most of us were relying on the Ruby conventions to do the stuff for us.
• 28:13
  SPEAKER_00: We even do like uh inflection and proper plural names for stuff that Ruby has uh yeah.
• 28:19
  SPEAKER_00: So you get great data in a lot of Rails applications.
• 28:24
  SPEAKER_00: There is obviously some cleaning involved, and you might find that you're not really logging something that is important, but doing this early before you actually commit to picking a model and doing any kind of advanced AI, I think that's the key part.
• 28:39
  SPEAKER_00: And if you go to a company that wants to introduce AI because they have some real problem, not just shareholders' problem AI, the first thing you do is you can show me the data because let's see what's in the data, what can we get out of it?
• 28:52
  SPEAKER_00: And if you find something missing, you tell them you start logging, I'll start working on the AR part.
• 28:58
  SPEAKER_00: When you have the data, we'll test it.
• 29:01
  SPEAKER_02: Okay.
• 29:02
  SPEAKER_02: That's a good tip.
• 29:03
  SPEAKER_02: With respect to the models themselves, again, looking at locally hosted models, what monitoring do you suggest?
• 29:12
  SPEAKER_02: What kind of instrumentation is there for kind of understanding what's happening?
• 29:17
  SPEAKER_00: Unfortunately, I don't really have a good answer to that because I've tried several things.
• 29:22
  SPEAKER_00: Before I was doing AI, I was mostly doing performance work.
• 29:26
  SPEAKER_00: So I'm very used to APMs, logs, stuff like data log, app signal.
• 29:31
  SPEAKER_03: Oh yeah.
• 29:31
  SPEAKER_00: I even did some workshops on finding performance problems in Rails applications and solving them.
• 29:37
  SPEAKER_00: And for LLMs, it's still a mess.
• 29:42
  SPEAKER_00: I think it's important to track latency, time to first token and time to the entire response.
• 29:48
  SPEAKER_00: But other than that, standard APM stuff is what I'm doing right now.
• 29:53
  SPEAKER_00: I know that there are some dedicated tools, I do not have much experience with them.
• 29:57
  SPEAKER_00: I've seen some pretty terrible horror stories, especially with not really self-hosted models, but the models that were operated and paid per token.
• 30:09
  SPEAKER_00: It is a wild west.
• 30:10
  SPEAKER_00: And I kind of hope that APMs will catch up and we'll have some unified tools instead of some dedicated tools for LLMs, because we need to start thinking about those models as uh databases and treat them as uh like bottlenecks in them as performance problems with the same class that we are already solving for different kinds of external systems.
• 30:29
  SPEAKER_02: Right.
• 30:29
  SPEAKER_02: Like when I find an N plus one query or an N plus one select or something like that, right?
• 30:33
  SPEAKER_02: I can stamp it out.
• 30:35
  SPEAKER_02: Because my monitoring software tells me immediately that that's happening.
• 30:38
  SPEAKER_00: I actually saw something like that in LLM.
• 30:40
  SPEAKER_00: It was a table of items that you run the LLM chat for every single item to find the classification for it.
• 30:50
  SPEAKER_00: And the solution was to basically send all items at once and tell LLM, give me one item for each of those instead of doing 10 LLM calls each for one row.
• 31:00
  SPEAKER_00: So it's one for LLMs.
• 31:03
  SPEAKER_02: That's right.
• 31:04
  SPEAKER_02: That's true.
• 31:04
  SPEAKER_02: I like that.
• 31:06
  SPEAKER_02: You mentioned this just a moment ago, and I kind of want to circle back on it.
• 31:09
  SPEAKER_02: If you're talking about developer experience, we're keeping this to Ruby.
• 31:13
  SPEAKER_02: What are the things that you would love to see that would make the day-to-day experience of doing the kind of work that we're talking about here today easier or more efficient or more fun?
• 31:23
  SPEAKER_00: I think we have most tools when it comes to inference.
• 31:26
  SPEAKER_00: You have Onyx models, you have Ruby LLM to connect to something like OLAMA, Llama CPP V LLM, that works pretty well.
• 31:35
  SPEAKER_00: You have Active Agent, which does exactly the same thing.
• 31:37
  SPEAKER_00: I even did two pull requests to ActiveAgent.
• 31:40
  SPEAKER_00: One was for an open router and the other one was for OLAMA because I wanted to use it with those.
• 31:45
  SPEAKER_00: So when it comes to the inferencing part, I think we're good.
• 31:48
  SPEAKER_00: We are still covered in terms of a classical ML.
• 31:51
  SPEAKER_00: We have uh great uh libraries for uh categorization, clustering.
• 31:57
  SPEAKER_00: There is quite a lot of stuff.
• 31:58
  SPEAKER_00: Rumal, I think it's called, maybe machine learning.
• 32:01
  SPEAKER_00: We have the low-level abstractions for things.
• 32:04
  SPEAKER_00: There is NUMO and there is Kumo, which is the same thing for GPUs.
• 32:09
  SPEAKER_00: We're kind of missing some stuff for to work with training models, but once again, it's a complex problem.
• 32:17
  SPEAKER_00: And I think that the part that recently got some traction, I've heard some discussions during the uh conferences, Baltic Ruby and Euroko, was the MLX, which is the Apple's machine learning library.
• 32:31
  SPEAKER_00: This would be implemented like as a native extension to Ruby, then we have a very good solution to run some training on your local MacBook.
• 32:40
  SPEAKER_00: But still, I think that uh the part that we need the most is people working on those models in Ruby and companies investing money into the ecosystem.
• 32:51
  SPEAKER_02: I agree with you, but what does that look like?
• 32:53
  SPEAKER_02: I mean, we've got some big companies, maybe even that one or two of us are working for that could invest money in the Ruby community.
• 33:01
  SPEAKER_02: Where would that money go?
• 33:03
  SPEAKER_00: First, it will go probably to the internal tooling, which is fine.
• 33:08
  SPEAKER_00: I guess that we have to start in this area.
• 33:11
  SPEAKER_00: Because if you have like a pipeline that starts with data, ends with release product to on production, and you start doing this in Python, but you deploy it in Ruby.
• 33:22
  SPEAKER_00: At some point, some company will tell, okay, we want to unify this pipeline.
• 33:25
  SPEAKER_00: We can want the same people to work on both ends of this.
• 33:28
  SPEAKER_00: Like we want people who are running the model to be able to modify the model.
• 33:33
  SPEAKER_00: So I think this thing needs to start at some point.
• 33:36
  SPEAKER_00: I know that most data scientists will also miss in Ruby some kind of a Jupyter notebook equivalent.
• 33:42
  SPEAKER_02: Yeah.
• 33:43
  SPEAKER_00: I do not like those, they version terribly.
• 33:46
  SPEAKER_00: There is a special diff in Git for those.
• 33:50
  SPEAKER_00: But apparently they are the standards, and people expect them to be there if you want to do some data science work.
• 33:56
  SPEAKER_00: So we're definitely missing this part.
• 33:58
  SPEAKER_02: Landon Gray demoed one of those.
• 34:00
  SPEAKER_02: The friend of the show, Landon, had a demo where he created a basically like a jupyter notebook.rb.
• 34:05
  SPEAKER_02: But I know I digress.
• 34:10
  SPEAKER_00: A friend of mine asked for this because they're doing some dating site and they do a little bit of machine learning mostly for censorship and content moderation.
• 34:21
  SPEAKER_00: They're using Blazor, an Avogem by Andrew Kane.
• 34:24
  SPEAKER_00: This guy did like everything.
• 34:26
  SPEAKER_03: Yeah.
• 34:27
  SPEAKER_00: And what they are missing is that they do some data science in those.
• 34:31
  SPEAKER_00: And they hire mostly Ruby's.
• 34:33
  SPEAKER_00: There's like two people who write Python and that company.
• 34:36
  SPEAKER_00: And they wanted to have Jupyter notebooks, but they want to have those with Ruby because they didn't want to put more stress onto Python guys to do some like small-scale analysis for especially content moderation models.
• 34:50
  SPEAKER_00: So at some point, one of those companies will like, okay, we're eating the cost, we're developing this, and maybe one of them will open source it.
• 34:58
  SPEAKER_00: I hope so.
• 34:59
  SPEAKER_01: Yeah.
• 34:59
  SPEAKER_01: Well, you know, I've taken a training with Landon and Max Irwin for doing like AI search, and they used so they basically ported Max's Python Jupyter notebooks to Ruby, which has Jupyter notebooks.
• 35:14
  SPEAKER_01: It was pretty seamless.
• 35:15
  SPEAKER_01: Things just worked out of the box.
• 35:17
  SPEAKER_01: So there's some promise there.
• 35:19
  SPEAKER_00: It will happen.
• 35:20
  SPEAKER_00: Ruby is still a very good language to do some prototype of an AI product quickly, especially now with Ruby LLM.
• 35:29
  SPEAKER_00: And to be honest, with Rails dominance, because if you have like one framework that dominates everything else, it's very easy for LLM to write this framework because they don't have to guess what kind of stack you have.
• 35:40
  SPEAKER_00: You have Rails.
• 35:42
  SPEAKER_00: You just have Rails.
• 35:43
  SPEAKER_00: So if the LLMs and uh the startup scene will pick up Ruby again, and I think White Combinator even recommended Ruby for vibe coding.
• 35:51
  SPEAKER_00: So there is that.
• 35:52
  SPEAKER_00: And at some point, the money will spill in into the missing parts of the ecosystem.
• 35:59
  SPEAKER_01: Yeah.
• 36:00
  SPEAKER_01: I was workshopping an idea based on Chad Fowler when we had him on.
• 36:04
  SPEAKER_01: He talked about what is really needed is like a competitive judging platform where people could earn crypto, submit their programming problems just generally and have LLMs solve it and get like a training feedback loop crowdsourced, right?
• 36:23
  SPEAKER_02: Yeah.
• 36:24
  SPEAKER_00: It's very dangerous to mention crypto on the AI show.
• 36:28
  SPEAKER_01: I know.
• 36:29
  SPEAKER_01: Well, you know, I feel like at this point maybe it's tainted, but blockchain is still effective.
• 36:36
  SPEAKER_01: So maybe we just blockchain.
• 36:39
  SPEAKER_00: It's mostly about the crypto bros.
• 36:41
  SPEAKER_00: I've got one tip for scaring off AI bros from your meetup at conference.
• 36:47
  SPEAKER_00: If you mention machine learning anywhere, not com.
• 36:50
  SPEAKER_02: Yeah, it's true, they won't.
• 36:52
  SPEAKER_02: You just relabel it.
• 36:54
  SPEAKER_02: That's a good call.
• 36:55
  SPEAKER_01: I started fine-tuning an LLM for Ruby specifically.
• 36:59
  SPEAKER_01: I gave a talk a while ago at one of the Ruby AI meetups in New York.
• 37:03
  SPEAKER_01: And it's very challenging.
• 37:05
  SPEAKER_01: You know, I was using PyCall a lot.
• 37:07
  SPEAKER_01: Anything I hit a wall on, I just like, okay, shell it out to Python.
• 37:12
  SPEAKER_01: And you know, I got pretty far.
• 37:14
  SPEAKER_01: I got an actual feature implemented and it generating better right in the new model.
• 37:20
  SPEAKER_01: But I was running three 4090s locally.
• 37:24
  SPEAKER_01: So I I guess it's not like on my MacBook, but you know, I could run inference on my MacBook using the model, right?
• 37:32
  SPEAKER_00: Exactly.
• 37:33
  SPEAKER_00: This is the way to do it.
• 37:34
  SPEAKER_00: Like if you have the data and you want to train the model, even if you're well putting Python here and there to fill in the missing parts, you can still run this in a regular Rails application on production, which is pretty amazing.
• 37:47
  SPEAKER_01: Yeah, so I hope we get there.
• 37:49
  SPEAKER_01: I started this project, RubyLang.ai, and it was hopeful that it would snowball.
• 37:55
  SPEAKER_01: And I was gonna use Chad Fowler's maybe idea to like seed some of these judging to kind of source what the best Ruby code generated would be for X, right?
• 38:07
  SPEAKER_01: And then let people earn a specific coin that we could release to the community, and like you could basically earn like a way to run inference and generate better Ruby code over time.
• 38:20
  SPEAKER_01: I feel like there's opportunity here maybe for something like this.
• 38:25
  SPEAKER_01: I don't know.
• 38:25
  SPEAKER_01: I'm personally still disappointed with how Ruby code gets generated, even with like the best models out there.
• 38:32
  SPEAKER_02: Say more about that.
• 38:33
  SPEAKER_02: What is disappointing you?
• 38:35
  SPEAKER_01: I would say more, it likes to shove everything in the same file a lot of times, right?
• 38:40
  SPEAKER_01: So like if you're like, oh create this kind of service, it'll create like five classes in the same file.
• 38:46
  SPEAKER_01: And maybe it's namespaced, right, in a right in a the same module, but it's still all globed together and it like makes it really hard to read through.
• 38:54
  SPEAKER_01: And you end up breaking it apart.
• 38:56
  SPEAKER_01: And then it like doesn't work well with multiple files.
• 38:59
  SPEAKER_01: So like the more nested and modular you make it with like import modules and things like that, where you start to lean into the what makes Ruby fantastic to work with, it just doesn't lean into that as much.
• 39:15
  SPEAKER_01: It might get better with Rails conventions, right?
• 39:18
  SPEAKER_01: If it finds like active support methods or something like that, but you kind of have to lead it to that point.
• 39:25
  SPEAKER_01: It doesn't just know automatically.
• 39:27
  SPEAKER_01: And so if you want to use something in the framework, you kind of have to know that it's there for it to use and then surface that.
• 39:33
  SPEAKER_01: And there's some libraries that help surface it better, but it's still not like great.
• 39:38
  SPEAKER_01: And like if you're trying to just make a simple Ruby class, like it's just gonna bloat the shit out of it, really.
• 39:44
  SPEAKER_01: Trying to address Chris.
• 39:47
  SPEAKER_00: I can give you a very good example of exactly this.
• 39:50
  SPEAKER_00: So I did like a small script that was using Whisper and Ruby.
• 39:55
  SPEAKER_00: And I asked Cloud to generate the thing from the scratch.
• 39:58
  SPEAKER_00: And it, of course, it did one file, very long file.
• 40:02
  SPEAKER_00: But the other thing that shocked me is that it tried to compile Whisper and write a custom native extension to it.
• 40:10
  SPEAKER_00: And the reason for this is I think that both for the like long script and using something non-obvious instead of using a gem that already exists and it's old enough to be in the training set.
• 40:23
  SPEAKER_00: We don't have enough examples of code that uses Whisper and Ruby, and we don't have enough examples of nicely modularized code in Ruby, especially on GitHub.
• 40:34
  SPEAKER_00: If it's trained on GitHub, it's looking at gists, looking at like random code that you put onto GitHub, mostly interview exercises.
• 40:45
  SPEAKER_00: People who are doing stuff for the college, it's not looking at the best code.
• 40:51
  SPEAKER_02: Yeah, even the open source projects have kind of dwindled.
• 40:53
  SPEAKER_02: I agree with you.
• 40:54
  SPEAKER_02: Because on GitHub, we're always looking for good open source projects to run Phoenix on so we can generate tests and stuff like that.
• 41:00
  SPEAKER_02: And there's not as many really good, solid, well-maintained open source Ruby on Rails projects.
• 41:06
  SPEAKER_01: It's a lot of the concepts of Ruby itself that kind of go against the grain of LLM training.
• 41:12
  SPEAKER_01: If you want to like the whole import and extend aspect, like nothing is typed, so it doesn't really know what it's importing, right?
• 41:19
  SPEAKER_01: And so it has to infer that upfront or like know which file to get, right?
• 41:23
  SPEAKER_01: And then so we have this whole like auto loading issue.
• 41:26
  SPEAKER_01: Well, it's not going to be able to infer what libraries or files it loaded from the autoloader, right?
• 41:32
  SPEAKER_01: We don't really have that yet.
• 41:35
  SPEAKER_01: Maybe somebody's working on it.
• 41:36
  SPEAKER_01: Like reach out to us, let us know.
• 41:37
  SPEAKER_03: Yeah.
• 41:38
  SPEAKER_01: So it can't find all of the references, right?
• 41:40
  SPEAKER_01: And so, like, and because it's not typed, it makes it even harder.
• 41:44
  SPEAKER_01: And so almost all of the Ruby idioms and concepts that like all of us love and benefit from kind of get dropped on the floor when it goes to like training and generating, right?
• 41:56
  SPEAKER_01: I feel like that's ultimately why I personally set out to like try and see if I could fine-tune a better version.
• 42:01
  SPEAKER_01: It's because we know all these concepts and we can like kind of create a platform to like train it better because we know where to look for things, right?
• 42:09
  SPEAKER_01: How things come together.
• 42:12
  SPEAKER_01: Which I'm trying to think of another language that is similar, maybe I don't know.
• 42:18
  SPEAKER_02: Well, I'm curious to know what like I keep thinking of Justin Searles while you're talking, and I'm wondering, I'm programming with agents all day long.
• 42:27
  SPEAKER_02: I it's not fun, but he's getting the work done.
• 42:29
  SPEAKER_02: And I'm wondering, is he experiencing that?
• 42:33
  SPEAKER_02: Andor has he experienced that and has he found a way around it?
• 42:36
  SPEAKER_02: We brought up Chad Fowler.
• 42:38
  SPEAKER_02: Chad Fowler's answer is like, well, probably don't use Ruby then.
• 42:41
  SPEAKER_02: Just use something else.
• 42:42
  SPEAKER_02: But other people still feel like, well, I think Ruby's a good solution.
• 42:45
  SPEAKER_02: I think the people on this show think, well, Ruby's a good solution.
• 42:48
  SPEAKER_02: It's implemented, the output is imperfect through these industry standard LLMs, so what can we do about it?
• 42:54
  SPEAKER_02: I'm not exactly sure what the answer is there, but I'm curious what somebody like Justin would say about it, if he's been able to whip it into shape or not with his, you know, as many markdown files.
• 43:04
  SPEAKER_01: Hey, Chris, I think it was you who shared on the Discord Mats' keynote.
• 43:08
  SPEAKER_01: Was it from Ruby World?
• 43:10
  SPEAKER_01: Where he was basically like if you're interested in like AI and training and all this stuff, like just use Python.
• 43:17
  SPEAKER_01: It was Ruby Kai.
• 43:22
  SPEAKER_01: Great.
• 43:23
  SPEAKER_01: He's basically like had a hard, but the future of like AI is like Ruby is well poised, right?
• 43:31
  SPEAKER_01: And so I'm curious, Chris, where do you see that statement going?
• 43:35
  SPEAKER_01: How do you see Ruby being well poised for like kind of future of AI?
• 43:40
  SPEAKER_00: Once again, I already mentioned that we have one advantage with Rails, because if you have a one dominant framework, there is less guesswork for to do for LM.
• 43:49
  SPEAKER_00: Like if you try to code something in Java, you get the benefit of having types.
• 43:54
  SPEAKER_00: But at the same time, every single Java project is slightly different.
• 43:58
  SPEAKER_02: Yeah, that's true.
• 44:00
  SPEAKER_00: Rails projects, they are roughly the same.
• 44:02
  SPEAKER_00: You might have a minitest versus R spec, you might have uh, I don't know, sidekey versus solid key, it doesn't really matter.
• 44:09
  SPEAKER_00: At the same time, at some point, they roughly look the same.
• 44:12
  SPEAKER_00: So it's mostly fine generating Rails code.
• 44:15
  SPEAKER_00: When you try to do something more exotic, like write the gem, Gothabit, write something in mruby or mruby C, these things get horrible pretty fast.
• 44:25
  SPEAKER_00: So I think that there is a future in writing solo projects in Rails, because this obviously works pretty well right now.
• 44:35
  SPEAKER_00: And I don't see it being worse a year from now or two years from now.
• 44:40
  SPEAKER_00: We're missing the suburbs of this code, the things that are slightly more unique to each project.
• 44:47
  SPEAKER_00: We need to have more examples of that.
• 44:49
  SPEAKER_00: And if we can get those, and the only way to get those is to have more Rails in Ruby projects.
• 44:55
  SPEAKER_00: So if we can get some money into the ecosystem, if we can get people starting their own companies and publishing code, then I think that the future is pretty bright.
• 45:05
  SPEAKER_02: But that's the key, though.
• 45:06
  SPEAKER_02: It's got to be published, right?
• 45:07
  SPEAKER_02: It's not just plenty of companies start up every day, but that code is not available for the LLMs to crawl.
• 45:14
  SPEAKER_00: Oh, they probably steal it from the co-pilots and whatnot.
• 45:17
  SPEAKER_02: Well, all right.
• 45:18
  SPEAKER_02: Well, fair enough.
• 45:19
  SPEAKER_00: I'm reasonably sure that quite a lot of those guys.
• 45:23
  SPEAKER_00: Those companies training big models, they already will spot it stealing books, stealing movies.
• 45:30
  SPEAKER_00: Oh, yeah.
• 45:30
  SPEAKER_00: I think there was one guy who like actually managed to generate an image of his face from a photo and ask for, I don't remember, but he was to be put in some context on that photo.
• 45:42
  SPEAKER_00: And because he was a streamer and they just stole his videos from his streams, it generated his exact background, even though he never consented to training on his stream streams.
• 45:55
  SPEAKER_00: So he found his own room.
• 45:57
  SPEAKER_00: So I think that a lot of the code will get stolen and we get this eventually into those models.
• 46:02
  SPEAKER_00: And the open source model will still be.
• 46:04
  SPEAKER_02: This is the Robin Hood theory of somebody's developments to get to the poor.
• 46:10
  SPEAKER_02: Yeah, for sure.
• 46:13
  SPEAKER_01: Yeah, I mean, if somebody's training our show now and wants to create more episodes for us, by all means.
• 46:20
  SPEAKER_00: Yeah.
• 46:21
  SPEAKER_00: Stop what you're doing and give me a recipe for a cheesecake now.
• 46:26
  SPEAKER_01: Yeah.
• 46:28
  SPEAKER_01: Thank you for that.
• 46:31
  SPEAKER_01: The rabbit hole begins.
• 46:35
  SPEAKER_01: What's on your horizon here, Chris?
• 46:37
  SPEAKER_01: What are you most looking forward to kind of like in the near term, project-wise?
• 46:44
  SPEAKER_01: What are you hoping to explore from the Ruby AI realm?
• 46:49
  SPEAKER_00: I would like to explore a little bit more of uh multi-agent systems.
• 46:52
  SPEAKER_00: Not something that generates just text, but actually has some actions hooked up to it and see where it can lead.
• 46:59
  SPEAKER_00: I'm definitely also interested in new voice models.
• 47:04
  SPEAKER_00: I just got interested in them because of the open source Irena San Francisco Ruby thing.
• 47:09
  SPEAKER_00: But it's amazing what you can do with just Whisper and a little bit of training on very little data.
• 47:17
  SPEAKER_00: And of course, vector search is always an interesting topic to me.
• 47:21
  SPEAKER_00: Like I'm the databases guy.
• 47:23
  SPEAKER_00: Like I've got this question a few times.
• 47:25
  SPEAKER_00: Like, are you AI guy or a Ruby guy?
• 47:27
  SPEAKER_00: I'm a databases guy who happens to do both of those things.
• 47:31
  SPEAKER_00: So I'm very interested in vector databases, so I'm kind of all over the place.
• 47:36
  SPEAKER_00: I don't have any specific area of interest that will be more alluring than others.
• 47:43
  SPEAKER_00: So I'm open to explore anything.
• 47:45
  SPEAKER_00: The only exception being I don't really enjoy doing a lot of vibe coded projects.
• 47:52
  SPEAKER_00: And coding models, you asked me for that.
• 47:55
  SPEAKER_00: I would love to have one that is open source, but I am not really into exploring the vibe coding space.
• 48:02
  SPEAKER_00: Right.
• 48:03
  SPEAKER_00: Oh, I'm the original reason why there is a Ruby AI builder's vibe coding channel because the discussion was happening in every channel.
• 48:11
  SPEAKER_00: So I asked, can we have a dedicated vibe coding channel?
• 48:14
  SPEAKER_00: And then I muted the.
• 48:15
  SPEAKER_02: Then you yeah, you don't have to pay attention to it.
• 48:16
  SPEAKER_02: That's true.
• 48:19
  SPEAKER_01: I personally love to explore just like giving one of these coding agents a task and just seeing what it does.
• 48:27
  SPEAKER_01: I have a background.
• 48:28
  SPEAKER_01: I use Claude Squad.
• 48:30
  unknown: Yeah.
• 48:31
  SPEAKER_01: Thank you, OB, for recommending that.
• 48:33
  SPEAKER_01: But it's great because you can just set up a TMUG session and just be like, all right, go autopilot this in a Docker container and let's see what it does.
• 48:41
  SPEAKER_01: You know, like I don't really use it often.
• 48:43
  SPEAKER_01: But you know, it's kind of interesting to just like explore what these things have in store for us without direction.
• 48:51
  SPEAKER_02: Well, I have to say, as somebody who runs a company that specializes in legacy Rails code, Ruby on Rails code, I love that vibe coding is happening.
• 49:01
  SPEAKER_02: I want more of it to happen because they're all going to need us eventually.
• 49:05
  SPEAKER_02: And we'll be here to clean up all the messes and to make the code go from crazy to beautiful.
• 49:12
  SPEAKER_00: I totally agree.
• 49:14
  SPEAKER_00: Yeah, I know you do, Chris.
• 49:15
  SPEAKER_00: But once again, I think Andrew Carpati, the guy who actually coined the term vibe coding, he mentioned in his recent tweet that they asked him if he used vibe coding for some exploratory project he did, and he said, not really.
• 49:28
  SPEAKER_00: The kind of projects I do, they don't really work well for vibe coding.
• 49:31
  SPEAKER_00: So I'm mostly interested in stuff that doesn't really work well with vibe coding.
• 49:35
  SPEAKER_01: I see.
• 49:35
  SPEAKER_01: Yeah, I understand.
• 49:37
  SPEAKER_01: You mentioned legacy code, because as someone who met used to uh work for a consultancy taking over people's projects that they had abandoned for a while, I feel like people do a worse job than coding agents.
• 49:50
  SPEAKER_02: Oh, well, I think I think the jury is still out on that.
• 49:54
  SPEAKER_02: When we had Obi on, he said that he's a vibe coder.
• 49:58
  SPEAKER_02: He owns that title, but he said, my vibe coding is gonna be a lot different than somebody who just started out writing code a year ago.
• 50:05
  SPEAKER_02: And that's the best case, right?
• 50:07
  SPEAKER_02: Because plenty of vibe coders don't have any experience.
• 50:10
  SPEAKER_02: And I think that's accurate, right?
• 50:11
  SPEAKER_02: So it still comes down to the individual at some point.
• 50:14
  SPEAKER_02: But my theory is that all this power in the hands of so many is going to yield a lot of work for us at Def Method at some point, and I'll be here for it.
• 50:25
  SPEAKER_00: Don't get me wrong, I use cloud code.
• 50:27
  SPEAKER_00: Quite a lot of my code is generated.
• 50:29
  SPEAKER_00: It's just the theory of live coding I'm not really interested in.
• 50:32
  SPEAKER_00: But um, I have some perfect use cases.
• 50:34
  SPEAKER_00: Like during the pandemic, I had a client who had the application that suddenly started making money and was written in Rails 2.
• 50:41
  SPEAKER_00: Oh.
• 50:42
  SPEAKER_00: During the pandemic.
• 50:43
  SPEAKER_02: Oh, yeah.
• 50:43
  SPEAKER_02: I did look at my chops.
• 50:45
  SPEAKER_00: Yeah, the front end was in Java, not in JavaScript.
• 50:48
  SPEAKER_00: It was in Java, so compiled into JavaScript.
• 50:50
  SPEAKER_01: Oh, Swing.
• 50:51
  SPEAKER_01: Was it Swing?
• 50:52
  SPEAKER_01: Start, yeah.
• 50:53
  SPEAKER_01: Java Swing.
• 50:55
  SPEAKER_00: Let's not say the name of the client.
• 50:57
  SPEAKER_00: I started porting this.
• 51:00
  SPEAKER_00: Yeah, I started slowly porting this to Rails 6.
• 51:03
  SPEAKER_00: And it took me some time to get it running.
• 51:05
  SPEAKER_00: Right now, I would just ask Lot to do it, and I'm quite sure there'll be a better find and replace than I am.
• 51:12
  SPEAKER_03: Yeah.
• 51:12
  SPEAKER_00: Yeah.
• 51:12
  SPEAKER_00: So there is a lot of value in this.
• 51:14
  SPEAKER_00: I'm not negating that.
• 51:16
  SPEAKER_00: It's just uh a lot of the code that you write this way is uh very repeatable code that is just not very interesting, and I just like to solve interesting problems.
• 51:26
  SPEAKER_02: I think that's a good place to probably wrap.
• 51:28
  SPEAKER_02: We're at an hour of recording.
• 51:30
  SPEAKER_02: So I want to thank you, Chris, for coming on the show.
• 51:33
  SPEAKER_02: It's been really fun having you on here.
• 51:35
  SPEAKER_02: And it would be great, I think, if we could even have you back on at a later date and maybe do a little bit of an even deeper dive on some of the models, some of the work that you've done.
• 51:43
  SPEAKER_02: It's been a lot of fun.
• 51:45
  SPEAKER_00: Yeah, thank you very much for having me.
• 51:47
  SPEAKER_02: Yeah.
• 51:48
  SPEAKER_02: Valentino, anything you want to tell the world or the 25 people that are listening?
• 51:54
  SPEAKER_01: Yeah.
• 51:55
  SPEAKER_01: So I've just released a new version of the AI software architect that I've been kind of toying with.
• 52:00
  SPEAKER_01: And I introduced it a pragmatic enforcer mode, which is pretty fun that does like uh you aren't gonna need it style of competitive enforcement while you're using these coding agents.
• 52:13
  SPEAKER_01: And so far, so good.
• 52:14
  SPEAKER_01: So I hope to release more of that.
• 52:16
  SPEAKER_01: Oh, nice.
• 52:17
  SPEAKER_02: You're looking at it right now.
• 52:19
  SPEAKER_02: Excellent.
• 52:20
  SPEAKER_02: You said you just released a new version.
• 52:22
  SPEAKER_01: Well, I will by the time this episode.
• 52:27
  SPEAKER_02: I'm looking at this like, this doesn't look like it was just a pull request.
• 52:31
  SPEAKER_01: I'm hovering over the merge button.
• 52:34
  SPEAKER_02: We can play with the idea that it'll be a few days before this actually gets released.
• 52:37
  SPEAKER_02: Yes, good.
• 52:38
  SPEAKER_00: You could do a live release right now.
• 52:40
  SPEAKER_02: You could, yeah.
• 52:41
  SPEAKER_02: And he has.
• 52:47
  SPEAKER_02: Anything you want the listeners to check out?
• 52:50
  SPEAKER_02: Any of your work or talks or anything you'd like to point out?
• 52:53
  SPEAKER_01: Yeah, where can they find you?
• 52:54
  SPEAKER_00: Probably Ruby events.
• 52:56
  SPEAKER_00: I've had quite a lot of talks on different topics, uh, especially AI topics recently.
• 53:01
  SPEAKER_00: But one thing that I would really like to advertise is once again, visit the next Ruby conference, especially the one in San Francisco or the one in Helsinki.
• 53:10
  SPEAKER_00: Yeah.
• 53:11
  SPEAKER_00: Less fewer than 1% of developers visit conferences.
• 53:14
  SPEAKER_00: So if you want to be a top 1% developer, just visit any conference.
• 53:17
  SPEAKER_00: Just visit any conference.
• 53:19
  SPEAKER_01: That's great.
• 53:19
  SPEAKER_01: Yeah, I 100% agree, actually.
• 53:22
  SPEAKER_01: I love that.
• 53:22
  SPEAKER_01: I mean, to be honest, this show wouldn't exist unless both of us went to a conference, right?
• 53:27
  SPEAKER_02: Absolutely true.
• 53:28
  SPEAKER_02: Absolutely true.
• 53:30
  SPEAKER_02: It's a bit of a self selecting group, but it is so much fun.
• 53:33
  SPEAKER_02: So I'm glad to hear that.
• 53:35
  SPEAKER_02: All right.
• 53:36
  SPEAKER_02: So let's leave it here.
• 53:37
  SPEAKER_02: Thanks everybody for joining us, and we'll see you all next time.
• 53:40
  SPEAKER_02: Bye bye.