Latest / The Ruby AI Podcast / Contracts and Code: The Realities of AI Development

Transcript

Contracts and Code: The Realities of AI Development · The Ruby AI Podcast

• 0:00
  SPEAKER_01: Hey everybody, welcome to another episode of the Ruby AI Podcast.
• 0:04
  SPEAKER_01: I'm your host, Valentino Stoll, and joined by co-host Joe Leo.
• 0:08
  SPEAKER_00: Hi, I'm Joe Leo.
• 0:10
  SPEAKER_00: I have one question for my co-host.
• 0:13
  SPEAKER_00: Whose contract is larger?
• 0:15
  SPEAKER_00: Juan Soto's contract with the New York Mets or your contract to be an AI engineer at Gusto?
• 0:23
  SPEAKER_01: You know, I wish I could be categorized with all these AI engineers.
• 0:27
  SPEAKER_01: Unfortunately, my frame of reference is not deep enough in the ML aspect of things to qualify, I think, for$100 million.
• 0:38
  SPEAKER_01: Yeah.
• 0:38
  SPEAKER_00: Yeah, that seems like it seems like a matter of positioning.
• 0:42
  SPEAKER_00: They teach you this when you're going out to the market with a product.
• 0:45
  SPEAKER_00: It's like, okay, well, if people view you as this, then maybe the product's only worth like$10.
• 0:50
  SPEAKER_00: But if they view you as this, you get a$200 million signing bonus.
• 0:54
  SPEAKER_01: And it's all marketing, right?
• 0:56
  SPEAKER_01: That like it's all marketing.
• 0:57
  SPEAKER_01: It should just be taught in uh all high schools, right?
• 1:00
  SPEAKER_01: Part of the curriculum.
• 1:02
  SPEAKER_00: Yeah, exactly.
• 1:02
  SPEAKER_01: I've how to market yourself.
• 1:04
  SPEAKER_01: Yeah.
• 1:04
  SPEAKER_01: How to market.
• 1:05
  SPEAKER_01: That's God, that's horrible.
• 1:08
  SPEAKER_00: I am thinking, like, I came across this thing.
• 1:11
  SPEAKER_00: It's called the Metis list.
• 1:13
  SPEAKER_00: You know, it's the world's top AI researchers.
• 1:16
  SPEAKER_00: I'll put it here in the show notes.
• 1:19
  SPEAKER_00: And so it's just ranked list.
• 1:20
  SPEAKER_00: And you know, you can see like Ilya there at the top, but then there's also all these names.
• 1:25
  SPEAKER_00: So I put my email in.
• 1:26
  SPEAKER_00: I don't know what they're going to send me, but I now can see the top 100 AI engineers ranked.
• 1:34
  SPEAKER_00: And it's like trading cards.
• 1:37
  SPEAKER_00: You can try and catch them all.
• 1:38
  SPEAKER_01: Well, so what are you gathering up from all this?
• 1:41
  SPEAKER_01: Just like how many hundreds of billions of dollars are in this list?
• 1:45
  SPEAKER_00: Or yeah, you know, I think it's interesting to note the disparity.
• 1:53
  SPEAKER_00: I'm not begrudging anybody on this list.
• 1:55
  SPEAKER_00: I want to be clear about that.
• 1:56
  SPEAKER_00: We have talked on the show before, I think, about how lucky we are, who are guys of people of a certain age who came to software development from a place of like, hey, this is interesting, and I could probably make a decent career.
• 2:11
  SPEAKER_00: And then all of a sudden, a few years in, software development became the hottest thing.
• 2:16
  SPEAKER_00: And all of the salaries increased and all of the demand for us increased.
• 2:22
  SPEAKER_00: No real work on my own part.
• 2:24
  SPEAKER_00: You know, the industry changed.
• 2:26
  SPEAKER_00: Now, nobody ever offered me$100 million, but I was able to live a nice life.
• 2:31
  SPEAKER_00: And so I think that's great.
• 2:32
  SPEAKER_00: Now I'm seeing this kind of turning.
• 2:34
  SPEAKER_00: And, you know, it's gotta be, there's obviously hype in this, right?
• 2:38
  SPEAKER_00: Nobody's worth$100 million.
• 2:40
  SPEAKER_00: It's a matter of scarcity and demand on the parts of these companies that have hundreds of billions of dollars at stake.
• 2:48
  SPEAKER_01: When I first saw these deals come out, like Facebook or whatever, you gotta think all these deals have to be tied up in equity, just like they would be if you were doing a startup, right?
• 2:59
  SPEAKER_01: Yeah.
• 3:00
  SPEAKER_01: Are these deals really like that incredible from like that perspective, right?
• 3:04
  SPEAKER_01: Or is it really just like the same deal with just more stock?
• 3:09
  SPEAKER_00: Like that's a great question.
• 3:10
  SPEAKER_00: And that also is a good alignment with sports because sports deals are always, it's all about the number, right?
• 3:16
  SPEAKER_00: And then when we dig in, we're like, well, this is really just a$20 million deal with a bunch of avoidable years at the end of it.
• 3:22
  SPEAKER_00: And yeah, I think the probably the same thing is true here.
• 3:25
  SPEAKER_00: It's like, yeah, you get a couple hundred million dollars if Meta wins the race, which nobody actually knows what that looks like.
• 3:32
  SPEAKER_00: Nobody I've talked to, maybe I should talk to these hundred people that are the smartest people ever.
• 3:36
  SPEAKER_00: But nobody knows what it looks like to win this AI race or why nobody's been able to satisfactorily answer me why it matters that one company does win.
• 3:47
  SPEAKER_00: Because so far, with the advent of LLMs, we've seen either incremental or tremendous improvements.
• 3:56
  SPEAKER_00: But after each improvement, there's always a short period of time when the next model by the next company catches up.
• 4:03
  SPEAKER_00: It doesn't seem like there is a huge gap or a huge way that somebody can build a moat and become the LLM that the human race uses.
• 4:13
  SPEAKER_01: I feel like recently kind of proven with like the Deep Seek releases, right?
• 4:18
  SPEAKER_01: Like everyone's just like, oh, well, like DeepSeek now is like just as good as OpenAI.
• 4:22
  SPEAKER_01: Like everybody's gonna use it, and it's just like not the case.
• 4:26
  SPEAKER_01: Yeah.
• 4:27
  SPEAKER_01: Well, that's true.
• 4:28
  SPEAKER_01: That's true.
• 4:28
  SPEAKER_01: And not that DeepSync isn't useful.
• 4:31
  SPEAKER_01: DeepSync has, you know, has great features and tasks that are really well performed by it.
• 4:37
  SPEAKER_01: But yeah, I feel like it's all about the vendor lock, right?
• 4:43
  SPEAKER_01: And like once you get people using it, it necessitates them continue using it.
• 4:49
  SPEAKER_00: I think that's a good point.
• 4:50
  SPEAKER_00: And we were talking about this right before the show started that what OpenAI built is a consumer tech product.
• 4:58
  SPEAKER_00: And the efficacy of the LLM behind it really is secondary to the experience that people have using it as a chatbot.
• 5:07
  SPEAKER_00: So that deep seek example is a perfect example.
• 5:10
  SPEAKER_00: You and I might go out and use the best models for whatever job that is at hand, and we might evaluate the different models and we might even find a way to objectively determine which one is best.
• 5:24
  SPEAKER_00: But most people are just reaching for open AI because that was the early leader, and everybody went out, myself included, and got themselves an open AI subscription so they could use Chat GPT.
• 5:36
  SPEAKER_01: We've talked before about okay, well, how do we test out, you know, all of our processes on different kinds of models or like watch what might happen?
• 5:45
  SPEAKER_01: Like, how are you doing that with Phoenix today?
• 5:50
  SPEAKER_00: The first thing we did, and this is now going back at least eight or nine months, and you know, the whole history of Phoenix is just one year.
• 5:58
  SPEAKER_00: It was called the September experiment when we started.
• 6:00
  SPEAKER_00: So we're coming up on one year.
• 6:02
  SPEAKER_00: We built a test harness that would run test generation against a number of different repositories.
• 6:10
  SPEAKER_00: We had a couple of open source repos, we had a couple of deaf method repos that we threw in there.
• 6:15
  SPEAKER_00: I think we had a customer repo that consented to have us do it.
• 6:18
  SPEAKER_00: And then we could run it against all of these different models.
• 6:20
  SPEAKER_00: That still exists, but we've found it lacking in the kind of efficacy that we needed because there is so much nuance to the test generation process.
• 6:35
  SPEAKER_00: And so it's great to say, okay, this works.
• 6:38
  SPEAKER_00: This one is the best model for generating specs end-to-end for a code base.
• 6:44
  SPEAKER_00: But, you know, we just got off the call with a prospect and they've got 1.2 million lines of code.
• 6:49
  SPEAKER_00: We're not going to just go and generate tests for the entire application.
• 6:53
  SPEAKER_00: It would, you know, it would cost an absolute fortune.
• 6:56
  SPEAKER_00: It would take, I don't know how long.
• 6:57
  SPEAKER_00: And it's not necessary, right?
• 7:00
  SPEAKER_00: We want to start with high flog scores, high complexity, high dependencies.
• 7:05
  SPEAKER_00: And so then it becomes like, okay, how well does it do in these different circumstances?
• 7:09
  SPEAKER_00: And then you throw in what dependencies are being used in that test, what needs to be mocked, what factories are available versus what is not available.
• 7:18
  SPEAKER_00: And I find it, maybe my engineers don't find it like this, but I find it to be an overwhelming number of variables to accurately say, okay, this one is the best.
• 7:29
  SPEAKER_00: And so then what happens is there's a lot of circumstantial evidence.
• 7:33
  SPEAKER_00: Well, this one worked really well for me.
• 7:34
  SPEAKER_00: So, like, this is my guy, ChatGPT5.
• 7:37
  SPEAKER_00: That's my guy.
• 7:38
  SPEAKER_00: But I talk to somebody else, and their guy is, you know, Gemini 4.
• 7:41
  SPEAKER_00: So it's hard to know.
• 7:43
  SPEAKER_01: You make a great point.
• 7:44
  SPEAKER_01: Like it's funny, like, if you dive into the open source large language model world, the first thing you learn is that every model has its own unique way of crafting prompts.
• 7:58
  SPEAKER_01: There are tricks that you can add to each different one that help signal the model in different ways.
• 8:06
  SPEAKER_01: Right.
• 8:06
  SPEAKER_01: Right.
• 8:07
  SPEAKER_01: Right.
• 8:07
  SPEAKER_01: And so, like, the same is true even of these bigger ones, right?
• 8:11
  SPEAKER_01: Like your GPT-5 prompt probably might not perform as well as like a O3 Mini or something, just because it was structured in a way that reasoning models would benefit from it.
• 8:24
  SPEAKER_00: Right.
• 8:24
  SPEAKER_01: Right.
• 8:25
  SPEAKER_01: And like maybe the GPT-5 model isn't as good at reasoning about the reasoning section of the prompt.
• 8:32
  SPEAKER_01: And then like you're just scoffing it up as, oh, this model isn't as good, right?
• 8:36
  SPEAKER_01: Right.
• 8:37
  SPEAKER_01: But really, it's like, well, the prompt needs to be different in order to justify that.
• 8:42
  SPEAKER_01: And then at that point, how are we like managing then?
• 8:46
  SPEAKER_01: It goes back to like there was a talk at the AI engineer conference where somebody was talking about prompts as like a compiled language.
• 8:57
  SPEAKER_01: And like basically people are thinking of them as like just kind of text that gets hydrated, but really it's like a compiled source code in a way with instructions for an LLM to complete.
• 9:10
  SPEAKER_01: You know, once you make an update to that, it like changes and it like recompiles and it like needs to like work differently.
• 9:17
  SPEAKER_01: And like you then can't use that compiled source code, plug it into Windows 95, right?
• 9:22
  SPEAKER_01: Like, right, yeah.
• 9:24
  SPEAKER_01: You know, like it's the same idea.
• 9:27
  SPEAKER_01: I'm definitely getting behind that.
• 9:29
  SPEAKER_01: And I don't know.
• 9:30
  SPEAKER_01: I feel like a lot of the prompting strategies libraries are like maybe misaligned in this way, where like I was hopeful with like the DSPY stuff that we could see maybe some self-improving things, but it's still almost too complicated from an instruction set standpoint to just like blanket apply prompts across the board, right?
• 9:53
  SPEAKER_00: Yeah, I think you raise a really interesting point.
• 9:55
  SPEAKER_00: And I'm curious to know in your role now at Gusto, do you have any benchmarks?
• 10:02
  SPEAKER_00: Do you have any hard and fast ways of saying, okay, new model came out?
• 10:06
  SPEAKER_00: I'm gonna determine whether or not it's better or worse for the use case that we have at hand.
• 10:12
  SPEAKER_01: We have many, many uh different kinds of evaluation test sets, right?
• 10:16
  SPEAKER_01: So it's always good to have like your core data sets that you're like churning off of for efficacy of whatever you're trying to measure against.
• 10:25
  SPEAKER_01: And so we do like build some golden data sets around what we're trying to test output for.
• 10:31
  SPEAKER_01: And yeah, we could swap models in and out, but again, it like circles back to like, well, are we gonna spend the time to try and like reprompt all these prompts that we have specifically for the new model?
• 10:42
  SPEAKER_01: Like, we don't really have that automated yet.
• 10:44
  SPEAKER_01: Now that I'm thinking about it, I probably want to now.
• 10:47
  SPEAKER_01: Yeah, see if see how possible that is, like get a prompt to reprompt it.
• 10:52
  SPEAKER_01: But at the same time, yeah, it's all about measuring just like output.
• 10:56
  SPEAKER_01: And so, like, how close can you get all your evaluations in line?
• 11:00
  SPEAKER_01: And there's an easy way to just drop in a new model and see, okay, is this gonna really have a measurable impact?
• 11:05
  SPEAKER_01: And like typically with these big ones, it's like negligible, right?
• 11:09
  SPEAKER_01: Like you might see like 0.1% or like sometimes 5% for some tasks as they come up with new releases too, like that may get improved too, right?
• 11:20
  SPEAKER_01: And so then you have to timestamp the fingerprint of the model and make test that because this whole juggling act, which I don't know, if you find the task that you want to solve, like is solved by a model, it's almost like, well, why change the model?
• 11:36
  SPEAKER_01: Right.
• 11:37
  SPEAKER_01: Create all this extra work.
• 11:38
  SPEAKER_00: Yeah, that's a fair point.
• 11:40
  SPEAKER_00: I do think that this is something that's missing.
• 11:43
  SPEAKER_00: There's going to be a company that comes along and kind of takes this off our hands, this benchmarking and evaluation.
• 11:50
  SPEAKER_00: Because what I'm hearing from you, you know, I hear from others as well.
• 11:54
  SPEAKER_00: And it always feels like, okay, well, we have this hand-rolled thing.
• 11:57
  SPEAKER_00: And that typically means that there's an opportunity there in the market that's not being addressed today.
• 12:02
  SPEAKER_01: Yeah, you know, at Doximity too, you prefer like setting up your pipelining and evaluation mechanisms around a vendor, right?
• 12:10
  SPEAKER_01: Like it's just so easy to just buy something and then plug in your data sets and then have it churn through the calculations.
• 12:17
  SPEAKER_01: But really, that's all it's doing.
• 12:19
  SPEAKER_01: Like all these services, they're all around like LLM as a judge.
• 12:23
  SPEAKER_01: So you pay for like the baseline evaluators to get you up and running to calculate something, and then you realize what those somethings are, and you're like, well, we want to add these specific calculations to target something, and then you realize, well, I gotta build out this whole thing, and like you'd be surprised how hard it is to like create these things.
• 12:44
  SPEAKER_01: It's really just an LLM call in the end, and so like, you know, and you can generate synthetic data even to like help insulate and cushion the data sets that you do have, so you have more data to test with that's you know similar and generated in similar ways that helps.
• 13:01
  SPEAKER_01: But yeah, at the same time, you always circle back to okay, well, we have too much custom things that we want to measure and test, and so you do just end up running your own out of necessity.
• 13:11
  SPEAKER_00: Uh yeah, no, I don't think it's an easy problem to solve.
• 13:14
  SPEAKER_01: Uh at the same time, so we had Klaus on an episode or two ago.
• 13:19
  SPEAKER_01: Yeah, and he presented the Leva Gem, like easy way to like just test stuff in Rails.
• 13:25
  SPEAKER_01: Really awesome.
• 13:27
  SPEAKER_01: And so I see kind of like more of that augmented service coming out just across the board.
• 13:35
  SPEAKER_01: Like I know we've mentioned Langsmith before, and that's like I don't know if they're free anymore.
• 13:41
  SPEAKER_01: They used to be free, yeah.
• 13:43
  SPEAKER_01: They're not, but that was the de facto, like, okay, yeah, you could just watch your traces and then like measure the impact.
• 13:50
  SPEAKER_01: Uh-huh.
• 13:51
  SPEAKER_01: And you know, that works great for a while.
• 13:53
  SPEAKER_01: And they've got some great tools.
• 13:55
  SPEAKER_01: I'm not gonna knock Langsmith.
• 13:57
  SPEAKER_01: If you're looking to set up your eval pipeline, it's all there.
• 14:01
  SPEAKER_01: I was hopeful when OpenAI had their like they have their own evaluations, I forget what they call it.
• 14:08
  SPEAKER_01: Yeah, I guess it's just evals.
• 14:10
  SPEAKER_02: Okay.
• 14:12
  unknown: Yeah.
• 14:13
  SPEAKER_01: So they have their like own built-in version of this where you can like sample all of the requests that come in through their API and then drop them in the data sets and then run tests against them.
• 14:24
  SPEAKER_01: And I think that they even have it set up so that you can take it a step further and like fine-tune based on what it finds out from some of that evaluation, which is kind of neat, but it's like I haven't had the desire to use it.
• 14:41
  SPEAKER_01: And I don't know if that's just like just me, or maybe there's something like you're mentioning, where it's like, you know, we want to stay model agnostic.
• 14:50
  SPEAKER_01: And so like we don't want necessarily tooling that's like tying us back into the thing that's locking us into the models.
• 14:59
  SPEAKER_00: I can easily see that as well.
• 15:01
  SPEAKER_00: That was but kind of the first thing that I thought of with eval.
• 15:05
  SPEAKER_00: Because I don't want a self-reinforcing, like, okay, I've made the decision to use open AI.
• 15:10
  SPEAKER_00: Let me use an open AI tool that convinces me that I gotta keep using it.
• 15:14
  SPEAKER_00: I also think that Langsmith has been good enough for us.
• 15:20
  SPEAKER_00: I think that you know, Langsmith has a real advantage in being a first mover, but there are other tools available.
• 15:27
  SPEAKER_00: We've stayed on Langsmith, I think there's some inertia there.
• 15:30
  SPEAKER_00: We haven't seen anything that is blowing us away in terms of being better.
• 15:35
  SPEAKER_00: But it's also, well, you know, it's not Ruby.
• 15:39
  SPEAKER_00: It's a SaaS product, but you know, it's a Python first solution.
• 15:42
  SPEAKER_00: And that was fine when we first started out.
• 15:44
  SPEAKER_00: But as more and more of our application is built in Ruby, and in our recent turn to integrating Ruby LLM into our application, we came up short in trying to do tracing and observability.
• 15:59
  SPEAKER_00: And, you know, and so one of our engineers went out and had to kind of roll their own tracing and observability and integrate it between Ruby LLM and Langsmith.
• 16:08
  SPEAKER_00: PR may be coming soon to Ruby LLM.
• 16:12
  SPEAKER_00: But it surprised me that there's nothing out of the box here, right?
• 16:15
  SPEAKER_00: Like because I think it is something that is just that new.
• 16:18
  SPEAKER_00: And I think, and I know you've got some opinions on this.
• 16:20
  SPEAKER_00: My take is that unlike evaluating in an objective manner what model is best for a particular task, that seems like a very big and onerous problem to solve, this doesn't seem like a big problem to solve.
• 16:32
  SPEAKER_00: This seems like something that should be solved again and again and again because there's a straightforward way to do it and you know when you've done it correctly.
• 16:40
  SPEAKER_01: I think it goes back to I feel like the open tracing days, right?
• 16:46
  SPEAKER_01: Like I guess we're still in them.
• 16:48
  SPEAKER_01: There was like, you know, this concept that like spread wide and is still kind of prevalent in ways of having like a distributed tracing mechanism that you just like hook into your application and your language, and it just works and attacks everything, and you can do spans if you want to get more focused on details.
• 17:11
  SPEAKER_00: That is open telemetry to an extent, right?
• 17:13
  SPEAKER_01: Yeah, open telemetry.
• 17:14
  SPEAKER_01: I guess it's yeah, I forget the transitionary period of each of those.
• 17:20
  SPEAKER_01: Yeah, open telemetry.
• 17:21
  SPEAKER_01: To me, this seems like the same problem, except we have like the whole streaming thing is like busting everything.
• 17:29
  SPEAKER_01: You know, there's so many failure modes now that we have to account for.
• 17:34
  SPEAKER_01: And then like, how does the tracing tie into those failure modes?
• 17:40
  SPEAKER_00: Yeah.
• 17:41
  SPEAKER_00: And you don't want the act of tracing itself to start contributing to the failure modes, right?
• 17:45
  SPEAKER_00: Right.
• 17:46
  SPEAKER_00: Because with more more streaming and more ways to connect, there's more tracing.
• 17:50
  SPEAKER_01: And then the data pipelining too, right?
• 17:52
  SPEAKER_01: It's like it's not like you're just sifting through logs anymore.
• 17:56
  SPEAKER_01: You're like calculating things based on those logs.
• 18:01
  SPEAKER_01: Maybe post-processing is still thing.
• 18:03
  SPEAKER_01: I feel like maybe the logging tooling had a miss here.
• 18:09
  SPEAKER_01: That's interesting.
• 18:10
  SPEAKER_01: In order to like just adapt to LLM usage.
• 18:13
  SPEAKER_01: You know, hey, just use your existing open telemetry and then oh, you can also like sample your data and pipe this into some evals.
• 18:22
  SPEAKER_01: Yeah.
• 18:22
  SPEAKER_01: I'm honestly surprised that that doesn't exist.
• 18:25
  SPEAKER_00: That's a fair point because rarely do we need this up to the minute.
• 18:30
  SPEAKER_00: Most of the time, I don't need to know the how much it costs for me to run this, you know, use this amount of inference on a model in real time.
• 18:37
  SPEAKER_00: But I may want to know at the end of the day or at the end of the week, the end of a month, you know, what are the hotspots.
• 18:44
  SPEAKER_00: And another big part of this, I didn't mention this before, was that there's a real cost-benefit analysis.
• 18:49
  SPEAKER_00: Whenever we're using the leading models, the big heavy hitters that are, you know, paying billions of dollars to make these incremental improvements.
• 18:57
  SPEAKER_00: Well, they're passing some of that cost on to us.
• 19:00
  SPEAKER_00: And whenever we can do something with one of the other models, whether it's open source or it's just a generation behind, we're going to save a whole lot of money.
• 19:07
  SPEAKER_00: And, you know, in our case, we're talking about continuous running.
• 19:10
  SPEAKER_00: You know, this thing is running all day long on your repository.
• 19:14
  SPEAKER_00: So it adds up quickly.
• 19:16
  SPEAKER_01: We're talking with Klaus in the in this previous episode, and like he gave like the most incredible talk at San Francisco Ruby AI meetup.
• 19:25
  SPEAKER_02: Yeah.
• 19:25
  SPEAKER_01: Where it was like, you know, he was showcasing the Leva Gem.
• 19:28
  SPEAKER_01: He used it specifically for this purpose you're talking about to like compare some, you know, lesser model to see how it performed and also how much money he's saving, so that as a business owner, he could decide, okay, is the like difference in quality worth the money I would spend on this model, right?
• 19:47
  SPEAKER_01: And he was like, I think his the example he showed was like uh GPT 4.0 mini or something versus like GPT, I think it was 4.0 at the time.
• 19:56
  SPEAKER_01: The percentage in quality loss from his evaluations were like, I don't know, 1% or 2% or something like that.
• 20:03
  SPEAKER_01: That's interesting.
• 20:03
  SPEAKER_01: And so he was just like, but the cost savings was like outrageous.
• 20:07
  SPEAKER_01: It was yeah, like 100% or 50%.
• 20:10
  SPEAKER_01: Yeah.
• 20:10
  SPEAKER_01: And so he was like, well, obviously I'm can make this decision to just use the cheaper model, right?
• 20:16
  SPEAKER_01: Yeah.
• 20:16
  SPEAKER_01: And so it's like interesting to see that exposure of like, okay, cost actually really does matter.
• 20:23
  SPEAKER_01: And it's like easy if you're in a bigger organization to maybe like just overlook that idea.
• 20:30
  SPEAKER_01: But at the same time, like it is needless spending.
• 20:34
  SPEAKER_00: It's needless spending.
• 20:35
  SPEAKER_00: And you know, when you're building products with AI, which I think we're gonna get into, you know, it used to be that their, you know, SaaS model was almost like zero marginal cost.
• 20:47
  SPEAKER_00: You had another user, it costs you just a couple of bytes, a couple extra minutes of EC2 or compute, and you know, and you're off and running, right?
• 20:54
  SPEAKER_00: It used to be like, well, we can cost us, I don't know, you know, half a million dollars a year in fixed costs to build this thing.
• 21:02
  SPEAKER_00: And so we need to make that up.
• 21:04
  SPEAKER_00: But then every time, every user we add that gets us over that is just profit.
• 21:09
  SPEAKER_00: That's not the case for, I can tell you from firsthand experience, that is not the case for AI products that leverage existing LLMs, especially commercially available LLMs.
• 21:21
  SPEAKER_00: The variable costs now are very high.
• 21:24
  SPEAKER_00: And the famous ones in our industry, the cursors and clients of the world, they lose money at just as rapid a pace as open AI does.
• 21:34
  SPEAKER_00: They just do it in smaller quantities, right?
• 21:36
  SPEAKER_00: There's an order of magnitude difference there.
• 21:38
  SPEAKER_00: But they're all losing money, right?
• 21:39
  SPEAKER_00: So, what do you do?
• 21:41
  SPEAKER_00: Not everybody wants to lose money.
• 21:43
  SPEAKER_00: I can also tell you from personal experience.
• 21:45
  SPEAKER_00: So, you know, so what does a small and medium sized business owner do when they've got a great idea, either internally or externally?
• 21:54
  SPEAKER_00: They want to leverage the LLM.
• 21:55
  SPEAKER_00: It's a continuous thing.
• 21:57
  SPEAKER_00: But now you need to be able to make Take back that cost.
• 22:01
  SPEAKER_00: And a lot of times you're doing that through some combination of price engineering, which is difficult because the loss leaders are charging just a few pennies and managing the costs on the other end, which I think Klaus had a really good idea there.
• 22:15
  SPEAKER_00: And it's something that we're starting to incorporate as well.
• 22:18
  SPEAKER_01: Yeah, it reminds me of whether you hire somebody right out of college or somebody that has 10 years of experience doing something.
• 22:27
  SPEAKER_01: You like to think of that as well, this person that has more experience is going to accelerate development of my product by this multiplier.
• 22:39
  SPEAKER_01: And the cost may be more upfront, but the value from that, like you get speed.
• 22:45
  SPEAKER_01: And so it's like a similar idea for like these models where you pay for the more expensive model in hopes that it's just faster at getting to what you want out of it.
• 22:56
  SPEAKER_01: Even though there's all these like free workers behind the scenes that you could be running, it'll take them a while, you know?
• 23:02
  SPEAKER_01: Like you know, if you spin up Claude Code with like Quinn 3 or something, you know, on your MacBook, it may take a few days to run something, but like you're gonna get it, yeah.
• 23:14
  SPEAKER_01: You're gonna get it, and it's free.
• 23:16
  SPEAKER_01: So like I guess the time, it's funny because like all of this AI is accelerating the everything, right?
• 23:24
  SPEAKER_01: And so like speed is almost like the most important part if you're like trying to innovate.
• 23:30
  SPEAKER_01: But if you're like truly just solving somebody's problem as a business owner, do you need that acceleration, right?
• 23:37
  SPEAKER_01: Like, are you gonna be dwarfed by some competitor because they're more innovative solving the same problem?
• 23:42
  SPEAKER_00: I honestly don't know.
• 23:44
  SPEAKER_00: Probably not.
• 23:45
  SPEAKER_00: I mean, that's not how businesses worked to date.
• 23:48
  SPEAKER_00: The first entrant into the market is not guaranteed to dominate that market forever.
• 23:52
  SPEAKER_00: It happens sometimes, but that's usually a business that has really worked hard to shore up what it does best and its customer service and all the rest of it.
• 24:00
  SPEAKER_00: And I still think that matters.
• 24:02
  SPEAKER_00: I've yet to see a case where that doesn't matter.
• 24:05
  SPEAKER_00: And so I think that's a I think that's a good point.
• 24:07
  SPEAKER_00: And I think that with respect to the models themselves, the changes I think what we're discussing here today is that the changes have always been incremental.
• 24:18
  SPEAKER_00: And now with Chat GPT five, we have this like mass realization or this mass kind of like understanding that, oh, hey, this was just a little incremental change.
• 24:29
  SPEAKER_00: Like every time we got a new version, everybody was kind of losing their minds for either good or not good reasons.
• 24:35
  SPEAKER_00: They were kind of elated by it.
• 24:37
  SPEAKER_00: Now we have ChatGPT five, and it's like, oh, okay, this is an incremental improvement, which is seen widely regarded as a failure by many people that I think outside of the tech community.
• 24:48
  SPEAKER_00: Whereas in the tech community, we're like, well, incremental's good.
• 24:51
  SPEAKER_00: You know, we'll take a little bit of an improvement here.
• 24:53
  SPEAKER_00: Let's see what it can do.
• 24:54
  SPEAKER_00: But the thing is that we really haven't scratched the surface of what these models can do.
• 24:59
  SPEAKER_00: And so getting something that's like an order of magnitude better, that could be great, but we're not even using what we have today.
• 25:08
  SPEAKER_01: Right.
• 25:08
  SPEAKER_01: Yeah.
• 25:09
  SPEAKER_01: I mean, that's a great point.
• 25:10
  SPEAKER_01: And it makes me think, like uh, I remember reading the release notes on OpenAI, and there's just like so many details of the API updates as they relate to the model specifically, that I think we're just so overlooked.
• 25:27
  SPEAKER_01: And it makes me think that it's like the Apple, like you're holding it wrong, right?
• 25:32
  SPEAKER_01: Like basically everybody has to like redo kind of some portions of what they've built in order to get the optimizations that are in play now, right?
• 25:41
  SPEAKER_01: And like I have a feeling this is gonna be a consistent iterative cycle like this.
• 25:47
  SPEAKER_01: The model may seem very underwhelming, but if you use all these other little features we've added, you're gonna be really wowed.
• 25:54
  SPEAKER_00: Yeah.
• 25:55
  SPEAKER_00: Do you have any examples of that?
• 25:57
  SPEAKER_01: Of what you read?
• 25:59
  SPEAKER_01: Oh, yeah.
• 26:00
  SPEAKER_01: So one example is you can now constrain tool outputs to specific grammars.
• 26:08
  SPEAKER_01: So like instead of just saying, oh, this structure of this tool is gonna return this specific structure from a parameter standpoint or attributes, and instead you can use an actual grammar like Ruby.
• 26:20
  SPEAKER_01: Ruby doesn't have a grammar, unfortunately.
• 26:23
  SPEAKER_01: But you know, some other languages have no programming languages have grammars, but you can make your own grammars.
• 26:28
  SPEAKER_01: And they're basically just like language templates that let you like generically describe how something should be respond in a formatted way.
• 26:38
  SPEAKER_01: And so like basically they made a way to make structured outputs very flexible and like more toward like language.
• 26:45
  SPEAKER_01: So like if you wanted something to generate in a report in a specific way, like you could just generate a grammar that is a report formatted in that way, and then all the outputs for that tool would return in that way.
• 26:58
  SPEAKER_00: Yeah, that is very cool.
• 27:00
  SPEAKER_01: So that's that's that's one example of it.
• 27:03
  SPEAKER_01: And another one is like they introduced this idea of preambles so you can ask the model to like think out loud before it makes a tool call, even.
• 27:14
  SPEAKER_01: So you can capture like if GPT 5 is reasoning about whether it should like call a tool, you can have it basically supply you that information ahead of time.
• 27:23
  SPEAKER_01: Yeah.
• 27:24
  SPEAKER_01: So that when you get your tool responses, when it's like, oh, you should make all of these tool calls, and it's like this is the reason why now.
• 27:31
  SPEAKER_01: Maybe you could be like, well, that reason does we don't really care about, right?
• 27:35
  SPEAKER_01: Like that could be useful, passing it along to some tool that makes another L11 call.
• 27:40
  SPEAKER_00: Um you need a human in the loop at that point, right?
• 27:43
  SPEAKER_00: Right, exactly.
• 27:44
  SPEAKER_00: Or another agent.
• 27:45
  SPEAKER_01: You could, yeah.
• 27:46
  SPEAKER_01: I mean, if you had an agent that you know you wanted to approve all the tool calls beforehand by somebody, even the front-end user, you could present that reasoning back to them and be like, this is why I think we need to do that, instead of you having to be like, Well, we think this is you know why we should call this tool.
• 28:02
  SPEAKER_02: Yeah.
• 28:02
  SPEAKER_01: You know, or just nothing, right?
• 28:04
  SPEAKER_01: Uh we're making it.
• 28:05
  SPEAKER_01: We just yeah, or we already did it.
• 28:08
  SPEAKER_01: Right.
• 28:08
  SPEAKER_01: We'll send you a bill.
• 28:13
  SPEAKER_01: Another one is like oh yeah, so you you can now get like reasoning tokens back and feed them back into subsequent calls.
• 28:22
  SPEAKER_01: I know they don't expose like the thinking steps you see in Chat GPT, but now you can basically get those for free if you do multi-turn responses.
• 28:32
  SPEAKER_01: So if you get like a response and it has reasoning in it, you can pass that back in your next call and it will be so close in proximity in the vector space that it can reuse it optimally and it doesn't have to like re-reason about things again.
• 28:47
  SPEAKER_01: Yeah.
• 28:47
  SPEAKER_01: Yeah.
• 28:47
  SPEAKER_01: I mean, these are just like small examples, I feel like, of what is to come in this kind of space.
• 28:55
  SPEAKER_01: Because you think like this is open AI, right?
• 28:57
  SPEAKER_01: Like Anthropic has like similar API with these other adjustments that you can use their API for, right?
• 29:05
  SPEAKER_01: Right.
• 29:05
  SPEAKER_01: And so it's like back to the compilation thing, like, well, okay, well, you can't just try an anthropic model up against GPT 5 and say, hey, can we just use anthropic, right?
• 29:17
  SPEAKER_00: Like so this is some way of translating the way that I prompt OpenAI over to the way that I prompt Claude to try to achieve the same result.
• 29:29
  SPEAKER_01: Right, exactly.
• 29:30
  SPEAKER_01: And like even on the API levels, maybe you use the API features differently for reasoning and anthropic than you would open AI because the models are formatted and structured a different way and built differently, to be honest, right?
• 29:45
  SPEAKER_01: So like it's funny people just being like, okay, like I entered this thing in the chat GPT, and look at this, what I entered it in the cloud, and they're completely different.
• 29:54
  SPEAKER_01: And it's like, well, yeah, it's not really apples and apples, you know?
• 29:58
  SPEAKER_01: Yeah.
• 29:58
  SPEAKER_01: And I may from a product standpoint it is, but I feel like there's just like you mentioned, like way too many parameters.
• 30:06
  SPEAKER_02: Yeah.
• 30:07
  SPEAKER_01: And so I wanted to circle back to the Ruby world for a minute.
• 30:11
  SPEAKER_01: Because you did mention Ruby LLM, like integrating that.
• 30:16
  SPEAKER_01: Yeah.
• 30:16
  SPEAKER_01: So like, how do you weigh that, right?
• 30:18
  SPEAKER_01: As a product builder, because like there's all this like hype lately about is AI actually delivering anything?
• 30:28
  SPEAKER_01: Right.
• 30:29
  SPEAKER_01: So, like, as a business owner, like building AI products, how do you decide like, okay, well, we should switch to using this framework, even, right?
• 30:38
  SPEAKER_01: Like, what is the value that that's going to even provide?
• 30:41
  SPEAKER_00: I know what you mean.
• 30:42
  SPEAKER_00: I mean, there's kind of two sides of it.
• 30:44
  SPEAKER_00: I'm a business owner with engineers that use AI to build an AI platform, right?
• 30:49
  SPEAKER_00: And so there's it's AI all the way down already.
• 30:52
  SPEAKER_00: And soon they'll just they'll just replace me with AI and then they'll take all the money.
• 30:59
  SPEAKER_00: But the decision for Ruby LLM was, I suppose it was twofold.
• 31:04
  SPEAKER_00: One was we're doing a lot of different work around the test generation process of Phoenix.
• 31:12
  SPEAKER_00: We are trying to improve the efficacy and efficiency of Phoenix.
• 31:17
  SPEAKER_00: And so there's graders that we're building and trying to analyze, okay, how good are these tests?
• 31:23
  SPEAKER_00: How do we put them back in the loop to make them even better?
• 31:25
  SPEAKER_00: Now, we've always had evaluations for the tests that we generate.
• 31:29
  SPEAKER_00: But in this case, we want to take, you know, we want to build our own just greater, our own assessment of how good these tests come out and try to make it as death method-esque as possible, right?
• 31:38
  SPEAKER_00: So we have our own opinions on it.
• 31:40
  SPEAKER_00: I don't think they're that controversial, but they're strong opinions loosely held about how tests should be formatted today.
• 31:48
  SPEAKER_00: So there's that piece, and then there's also this piece of when we started this 12 whole months ago, there were not a lot of Ruby LLM integration options.
• 31:59
  SPEAKER_00: And so we built a lot of it in Python.
• 32:02
  SPEAKER_00: And so when, for example, ActiveAgent, we had Justin on the show, you know, that didn't exist when we started Phoenix.
• 32:10
  SPEAKER_00: And so we have, we've always had a Ruby and a Rails application because there's a web app behind this.
• 32:18
  SPEAKER_00: But the lower level, the test generation was done in Python.
• 32:22
  SPEAKER_00: So that is still the case.
• 32:24
  SPEAKER_00: But more and more of the application, as we're getting deeper into the end-to-end integration of both test generation and then generating new tests for new code that's added, creating Everflame reports where we're evaluating the tests and the code as it comes in, those kind of end-to-end features, more and more we're able to say, okay, well, we want to do this with Ruby.
• 32:44
  SPEAKER_00: Or in some cases, it is advantageous for us to do this in Ruby.
• 32:48
  SPEAKER_00: So we went out and we did an evaluation.
• 32:50
  SPEAKER_00: We looked at sublayer, we looked at ActiveAgent, we looked at Roast.
• 32:54
  SPEAKER_00: We started with Roast for that evaluation piece that I mentioned, which is not part of the web app, but we started Roast for the evaluation piece.
• 33:02
  SPEAKER_00: It didn't hold up well, and I think that is probably because it's not being sunseted, but I think it is not being as actively developed as it was, which is funny.
• 33:13
  SPEAKER_00: You know, we had Obi on here like six weeks ago, and it's like, well, you know, things change.
• 33:17
  SPEAKER_00: Things change quickly.
• 33:18
  SPEAKER_00: And I think Obi himself, I could be wrong about this, but I think he's also more in favor of putting more effort into Ruby LLM and seeing that become sort of the leader for AI integration.
• 33:32
  SPEAKER_00: And then when we look at Ruby LLM compared to Sublayer and Activation, I love both of the maintainers on these projects.
• 33:39
  SPEAKER_00: There's not as much support, there's not as much use.
• 33:42
  SPEAKER_00: And so we decided we'd plunge in with Ruby LLM.
• 33:45
  SPEAKER_00: And so far, so good.
• 33:47
  SPEAKER_00: It's only been a couple of weeks.
• 33:48
  SPEAKER_00: And as I've mentioned, you know, it doesn't have out-of-the-xport for tracing and observability.
• 33:53
  SPEAKER_00: So we had to roll our own.
• 33:55
  SPEAKER_00: But we have felt like it has really added a boost.
• 33:59
  SPEAKER_00: It's definitely helped us shore up that end-to-end integration.
• 34:02
  SPEAKER_00: So, you know, we're happy with it.
• 34:05
  SPEAKER_01: Yeah, that's awesome to hear.
• 34:07
  SPEAKER_01: I haven't had a chance personally to play with Ruby LLM.
• 34:11
  SPEAKER_01: I think the structured outputs was maybe preventing me from messing with it, which is now in there.
• 34:16
  SPEAKER_01: So like uh I'll probably circle back and look at it.
• 34:18
  SPEAKER_01: Check it out.
• 34:19
  SPEAKER_01: It's kind of funny, like the Ruby AI gem, or Ruby Open AI gem, rather, you know, that was our de facto like gold standard.
• 34:28
  SPEAKER_01: And now it's well, how do we get all these other LLMs in there?
• 34:33
  SPEAKER_01: And yeah, it's you know, Langchain RB seemed promising, and that works great.
• 34:40
  SPEAKER_01: And then as all of these APIs evolve, like somebody's like, oh, Ruby LLM, like I'm gonna make all the things that I'm missing from all these other libraries and release this.
• 34:51
  SPEAKER_01: And then at what point does like that just keep continuing, and like somebody else comes out and is just oh, I'm making the LLM gem, and it's just like this is what you use for it.
• 35:01
  SPEAKER_01: Yeah, yeah.
• 35:02
  SPEAKER_00: Yeah, I mean, I I wrote about this or I talked about this in a talk that is uh it was back in, I don't know, March.
• 35:09
  SPEAKER_00: So it's probably everything I said back then was absolute, is obsolete now.
• 35:12
  SPEAKER_00: Right.
• 35:13
  SPEAKER_00: But one thing that I I stressed to the developers was being able to, you have to make things you know modular and you had to reduce the dependencies on your integration points because you're gonna switch them out.
• 35:27
  SPEAKER_00: Right.
• 35:28
  SPEAKER_00: And I think that goes for these gems as well.
• 35:30
  SPEAKER_00: It goes for roast, it goes for Ruby LLM, whatever you're using right now, it might be the thing that you want to use a year from now, but the chances are not good.
• 35:39
  SPEAKER_00: And so for that reason, you know, you cannot tightly couple.
• 35:43
  SPEAKER_00: And you know, we've always been warned about this, right?
• 35:45
  SPEAKER_00: Like tight coupling.
• 35:46
  SPEAKER_00: But now it's like, hey, you know, the thing that you're using today, you may not want to switch, but you oh you want to test something new out, and you're gonna want to do that over and over and over again because the field is evolving so quickly.
• 35:57
  SPEAKER_01: It does come down to just, I feel like standardization, which is so boring, especially for AI, which is like, oh, all this new, new, new, you know, and like when it comes down to it and you're maintaining this stuff, you're just like, Man, I wish like there was a standard.
• 36:13
  SPEAKER_01: Yeah, no, I totally agree with you.
• 36:15
  SPEAKER_01: Thank God for anthropic with MCP and like that actually taking hold, which is like a little weird because like there was like the open API standard, which is like essentially the same thing, yeah.
• 36:27
  SPEAKER_01: But at the same time, you know, like okay, like everybody just get behind this one thing and then we're gonna push it hard.
• 36:33
  SPEAKER_01: I feel like you know, Ruby is great at like polar opposing both forces here, right?
• 36:40
  SPEAKER_01: Like being innovative and just like doing everything all the same, all different ways, and also like coming getting behind something eventually.
• 36:49
  SPEAKER_00: Well, because that's what Rails is, right?
• 36:51
  SPEAKER_00: We could have just kept creating web apps and deciding where to put our models every single time.
• 36:56
  SPEAKER_00: And Rails said actually, you just put them here, they go here.
• 36:59
  SPEAKER_01: Right.
• 36:59
  SPEAKER_01: Yeah, exactly.
• 37:00
  SPEAKER_00: And that was still there.
• 37:13
  SPEAKER_00: And it's in an expected place.
• 37:14
  SPEAKER_00: It's more important that there's a convention than that you can configure it.
• 37:18
  SPEAKER_00: And I think there's a lot of that in AI and in this world.
• 37:22
  SPEAKER_00: We may not know what which is which yet, like what the most important thing is to abstract away, and what's the most important thing to just let developers be creative and explore.
• 37:32
  SPEAKER_01: Yeah, totally.
• 37:34
  SPEAKER_01: And it seems at this point that speed is almost outtrumping long-term support in a way.
• 37:43
  SPEAKER_01: I worry a little bit about it, but like I feel like Ruby's very you could just monkey patch anything, you know?
• 37:52
  SPEAKER_01: Yeah.
• 37:52
  SPEAKER_01: You know, you just go in and be like, okay, like this class is like, oh, we're gonna eval in real time, like to do something completely different than what it was like built for.
• 38:03
  SPEAKER_01: And I feel like, well, it's not maybe the best thing to do.
• 38:06
  SPEAKER_01: It's like something you can do, you know.
• 38:09
  SPEAKER_01: Something you can do.
• 38:10
  SPEAKER_01: Yeah, it's true.
• 38:11
  SPEAKER_00: I wonder how different that is.
• 38:13
  SPEAKER_00: Uh, you know, being in the world of software engineering services for as long as I have, you know, people have, you know, they've committed atrocities of programming so that they could get, they can go from zero to one and get their next round of funding.
• 38:27
  SPEAKER_00: And the answer is always, well, we'll fix it with the next round of funding, right?
• 38:30
  SPEAKER_00: And and some people actually do and commit to it, and some people don't, because it's just more important to chase the next thing and chase the next vertical curve in in user adoption.
• 38:41
  SPEAKER_00: This definitely it accelerates that kind of problem, but I don't think it's a new problem.
• 38:46
  SPEAKER_01: Right.
• 38:47
  SPEAKER_01: Yeah, it's definitely not a new problem.
• 38:50
  SPEAKER_01: This reminds me like there was this the hype cycle over Rails, which the hype dropped off and people are still using it.
• 38:58
  SPEAKER_01: And now it's like it's not a hype, but it's like popular, right?
• 39:04
  SPEAKER_01: Yeah, so like a hype versus popularity, right?
• 39:07
  SPEAKER_01: And so, like, where are we leading in this AI space with Ruby of uh like Ruby LM is a great example of popularity, right?
• 39:16
  SPEAKER_01: Like there was a hype around it, and now it's like really just becoming popular.
• 39:20
  SPEAKER_01: Yes.
• 39:21
  SPEAKER_01: Uh and so, like, great, use that tool.
• 39:23
  SPEAKER_01: You know, what else is coming out, right?
• 39:25
  SPEAKER_01: Like, what else is like are we facing from a hype cycle perspective?
• 39:31
  SPEAKER_01: We don't have to go into the coding world, agent world yet, right?
• 39:35
  SPEAKER_01: But uh that's feel like it's its own episode.
• 39:38
  SPEAKER_00: It's coming, yeah, it's coming.
• 39:39
  SPEAKER_00: Don't worry, tune in next week.
• 39:41
  SPEAKER_01: Yeah.
• 39:43
  SPEAKER_01: But like, where does Ruby fit in that AI building business space?
• 39:47
  SPEAKER_01: Like from a, okay, like it's no longer a hype and it's really just popular.
• 39:52
  SPEAKER_01: And like why is it a good use case, right?
• 39:55
  SPEAKER_01: That we keep coming back to, right?
• 39:58
  SPEAKER_01: Like it's more than just like Ruby is, it's like, okay, people are you know innovating on things still, and it's like becoming a useful tool to use it for that.
• 40:07
  SPEAKER_00: I would say that we're engineers.
• 40:10
  SPEAKER_00: If you're listening to this podcast, you're probably an engineer or you're my mom.
• 40:14
  SPEAKER_00: So hi, mom.
• 40:15
  SPEAKER_00: And I think it's actually it's incumbent on us to rise above the hype.
• 40:20
  SPEAKER_00: That's our job because the hype has always been there.
• 40:23
  SPEAKER_00: And the hype for Ruby and and even Ruby on Rails needed to dissipate.
• 40:28
  SPEAKER_00: And it's okay to get caught up, but the fact is that at the end of the day, we're building useful tools that we want to stand the test of time.
• 40:38
  SPEAKER_00: And that's always been, at least for me as a software engineer that takes himself seriously as a software engineer.
• 40:44
  SPEAKER_00: I judge my own abilities and success on whether or not the applications I build are still around in a few years, right?
• 40:52
  SPEAKER_00: They're useful, they serve a purpose.
• 40:54
  SPEAKER_00: Most of the time, they either earn money or they are funded, right?
• 40:58
  SPEAKER_00: If it's a nonprofit, but those tools that I build are still being used.
• 41:02
  SPEAKER_00: And if they're not, I think, well, I have something to learn from that.
• 41:05
  SPEAKER_00: And I think the same thing is true for us here.
• 41:08
  SPEAKER_00: It is easy to get caught up in AI hype, especially when there's a new tool coming out every five minutes that we can go and check out.
• 41:15
  SPEAKER_00: And I think it's okay to, and this is where the Ruby comes in, it's a great place to explore.
• 41:22
  SPEAKER_00: You know, we had Chad Fowler on the show, and he was talking about some other languages that might be better suited for automation or code gen with AI.
• 41:32
  SPEAKER_00: And that may be true, but Ruby still is the best for the user experience of the developer to play with things, to figure things out, to try things out.
• 41:42
  SPEAKER_00: And I think it's by doing that, it's by doing that creative work, we learn what is actually just hype and it's not actually going to be lasting for the test of time.
• 41:51
  SPEAKER_00: And what is, as you put it, popular and suitably popular and serving a good function.
• 41:57
  SPEAKER_01: Yeah, hopefully more thanks.
• 41:59
  SPEAKER_01: Yeah.
• 42:00
  SPEAKER_01: Because you know, it is the Ruby nature to make things that are not useful at all and just fun.
• 42:06
  SPEAKER_00: Yeah, I think that's good.
• 42:07
  SPEAKER_00: That's how you learn, though, right?
• 42:09
  SPEAKER_01: That is true.
• 42:10
  SPEAKER_01: Yeah.
• 42:10
  SPEAKER_01: Which is funny.
• 42:11
  SPEAKER_01: I just found out about this thing called Y Day, where it's like a memorial event that happens every August 19th.
• 42:21
  SPEAKER_01: To like inspire the Ruby community to see how far you can push the weird corner of Ruby.
• 42:27
  SPEAKER_00: That's funny, but you know, uh the thing is that Y Day exists because everybody got something out of Why the Lucky Stiff, right?
• 42:34
  SPEAKER_00: Right.
• 42:34
  SPEAKER_00: You know, he was being playful and he did something that was great.
• 42:38
  SPEAKER_00: Okay, I'm sorry.
• 42:38
  SPEAKER_00: So continue, I'm gonna get off this.
• 42:41
  SPEAKER_01: But as an example, I was like, well, like let me have a Claude, you know, take this description of Y Day and see like what it comes up with idea-wise.
• 42:49
  SPEAKER_01: And it came up with these two incredible ideas.
• 42:53
  SPEAKER_01: One was around quantum Ruby, so creating a version of Ruby that sometimes executed and sometimes didn't based on your observation of it.
• 43:04
  SPEAKER_01: And so like basically there would be a quantum state, and like if you were observing the code executing, then it would execute.
• 43:12
  SPEAKER_01: Otherwise, it would be in this weird holding pattern.
• 43:16
  SPEAKER_02: Yeah.
• 43:17
  SPEAKER_01: And then there was the Schrdinger state of like, you know, maybe it does, maybe it doesn't.
• 43:22
  SPEAKER_01: Right.
• 43:23
  SPEAKER_01: Right.
• 43:24
  SPEAKER_01: Very much in line, right?
• 43:25
  SPEAKER_02: Yeah.
• 43:26
  SPEAKER_01: Yeah.
• 43:27
  SPEAKER_01: And another one was just like, oh, what was it?
• 43:30
  SPEAKER_01: It was an emoji rubber duck session.
• 43:33
  SPEAKER_01: And so, like, basically, like opening up a Ruby console where like you can use emojis to define your code.
• 43:42
  SPEAKER_01: Yeah.
• 43:42
  SPEAKER_01: And depending on the kinds of emojis you used, you could like make it run faster or slower.
• 43:49
  SPEAKER_01: Nice.
• 43:49
  SPEAKER_01: You could like put it in angry mode, you know, and like have more errors raised.
• 43:55
  SPEAKER_01: Yeah.
• 43:56
  SPEAKER_01: Yeah, I like that.
• 43:58
  SPEAKER_01: So I don't know.
• 44:00
  SPEAKER_01: I feel like it's what helps the Ruby community be so popular, but also maybe how it prevents it from being taken seriously in a lot of ways.
• 44:11
  SPEAKER_00: Yeah, I'm okay with that.
• 44:13
  SPEAKER_00: I mean, let's put this another way.
• 44:14
  SPEAKER_00: If you're doing that, and I've got another example as well, but if you're doing that, then maybe you're resisting the urge to do something like create the next billion dollar company with just one person, right?
• 44:28
  SPEAKER_00: Like that's everybody taking themselves, I think, way too seriously.
• 44:31
  SPEAKER_00: So we could learn a lesson from why, you know, the whys of the world.
• 44:35
  SPEAKER_00: And from your example, V, where it's like, hey, you know what?
• 44:38
  SPEAKER_00: I built this thing and it's, isn't it funny and isn't it silly?
• 44:40
  SPEAKER_00: And we did this with AI.
• 44:41
  SPEAKER_00: Right.
• 44:42
  SPEAKER_00: And because I think that tinkering is actually really important.
• 44:45
  SPEAKER_00: And I think it's a lot of fun.
• 44:47
  SPEAKER_01: Yeah.
• 44:47
  SPEAKER_01: The serious notes, I definitely align with the anti-pattern there.
• 44:52
  SPEAKER_01: Maybe that's where Ruby really shines.
• 44:54
  SPEAKER_01: It's just like that it grinds against the you know draconian seriousness of everything.
• 45:00
  SPEAKER_01: Right.
• 45:00
  SPEAKER_00: Look at how look how great this thing is.
• 45:02
  SPEAKER_00: We all have to become rich.
• 45:03
  SPEAKER_00: We all have to, you know, or it's got to take over the world.
• 45:06
  SPEAKER_00: Like we don't have to be in this world of absolutes all the time.
• 45:10
  SPEAKER_00: Right.
• 45:11
  SPEAKER_00: My thing that I've been checking out, I think I've mentioned this before, but if you're not already reading Scott Werner's works on my machine Substack, he has been churning out, I've been following it for a while, but in the last few weeks and been churning out this outstanding content.
• 45:27
  SPEAKER_00: I mean, I think that he is one of the most creative thinkers of the usage of AI, how it works in your code, how you can leverage it.
• 45:35
  SPEAKER_00: So what he released recently were these two new gems, VSM and Airby, and his post about it and why he did it and how he feels like it can be a template for artificial intelligence systems that need to iterate and loop into all the things that we talked about on this show.
• 45:54
  SPEAKER_00: Check that out.
• 45:54
  SPEAKER_00: We'll put it in the show notes and give them both a try.
• 45:58
  SPEAKER_01: We're gonna have to get him back on to talk about these because like uh this is definitely the future.
• 46:03
  SPEAKER_01: And I don't know how he comes up with this content because I know he's he must have a lot of coffee, he says.
• 46:08
  SPEAKER_01: I know I feel like he just like talks about this in his you know living room or kitchen.
• 46:14
  SPEAKER_01: Yeah, yeah.
• 46:17
  SPEAKER_02: Yeah, yeah.
• 46:18
  SPEAKER_01: But yeah, totally like the self-building runtime style nature that he's gearing toward.
• 46:26
  SPEAKER_01: I think it's just what so many people have been talking about, but haven't figured out how to do it.
• 46:33
  SPEAKER_01: And it this is very promising.
• 46:35
  SPEAKER_00: I would put money on him to figure it out or at least figure out some large piece of it.
• 46:39
  SPEAKER_00: You know, I don't know if this is it.
• 46:40
  SPEAKER_00: He doesn't know if this is it, but this is worth checking out.
• 46:43
  SPEAKER_01: Yeah, totally.
• 46:44
  SPEAKER_01: All right, well, we we've talked about a lot.
• 46:47
  unknown: Yeah.
• 46:49
  unknown: Yeah.
• 46:50
  SPEAKER_01: Uh is there anything else you want to dive into?
• 46:52
  SPEAKER_01: I feel like we've hit all the corners.
• 46:54
  SPEAKER_01: Yeah.
• 46:55
  SPEAKER_01: Like we can, I think we can how do you measure AI in reasonable ways in Ruby space, tracing all of this fun stuff that really isn't solved.
• 47:07
  SPEAKER_01: Yeah, yeah.
• 47:09
  SPEAKER_01: Right.
• 47:10
  SPEAKER_01: I don't know.
• 47:10
  SPEAKER_01: Hopefully, somebody listening is like gonna come out and be like, yeah, you just use this thing now.
• 47:16
  SPEAKER_01: You know?
• 47:16
  SPEAKER_01: Oh, yeah.
• 47:17
  SPEAKER_01: Yes.
• 47:18
  SPEAKER_00: If you are that person and you're thinking, I can't believe these guys just talked about this for 45 minutes where there is an obvious answer.
• 47:24
  SPEAKER_00: Don't be shy.
• 47:26
  SPEAKER_00: You can shout that at me on social media or you know, my email.
• 47:29
  SPEAKER_00: You know, just let me know.
• 47:30
  SPEAKER_01: Otherwise, we'll just keep talking about how this, you know?
• 47:34
  SPEAKER_01: Yeah, yeah.
• 47:35
  SPEAKER_00: Otherwise, we'll drive you slowly insane with this mindless chatter.
• 47:41
  SPEAKER_00: All right.
• 47:42
  SPEAKER_00: Well, this was great.
• 47:43
  SPEAKER_00: Very happy to be on here and talking about this stuff.
• 47:46
  SPEAKER_00: We'll do it again soon.
• 47:48
  SPEAKER_00: All right.
• 47:49
  SPEAKER_00: Thanks for listening.
• 47:50
  SPEAKER_00: Take care, everybody.