The Ruby AI Podcast

Send us Fan Mail

In this episode of the Ruby AI Podcast, hosts Valentino Stoll and Joe Leo
welcome AI and Ruby expert Chris Hasinski. They delve into the benefits and
challenges of self-hosting AI models, including control over model updates, cost
considerations, and the ability to fine-tune models. Chris shares his journey
from machine learning at UC Davis to his extensive work in AI and Ruby, touching
upon his contributions to open source projects and the Ruby AI community. The
discussion also covers the limitations of current LLMs (Large Language Models)
in generating Ruby code, the importance of high-quality data for effective AI,
and the potential for Ruby to become a strong contender in AI development.
Whether you're a Ruby enthusiast or interested in the intersection of AI and
software development, this episode offers valuable insights and practical
advice.

00:00 Introduction and Guest Welcome
00:31 Why Self-Host Models?
01:28 Challenges and Benefits of Self-Hosting
03:14 Chris's Background in Machine Learning
04:13 Applications Beyond Text
06:39 Fine-Tuning Models
12:27 Ruby in Machine Learning
16:06 Distributed Training and Model Porting
18:22 Choosing and Deploying Models
25:19 Testing and Data Engineering in Ruby
27:56 Database Naming Conventions in Different Languages
28:19 Importance of Data Quality for AI
18:03 Monitoring Locally Hosted AI Models
29:37 Challenges with LLMs and Performance Tracking
31:09 Improving Developer Experience in Ruby
31:45 Ruby's Ecosystem for Machine Learning
32:43 The Need for Investment in Ruby's AI Tools
38:25 Challenges with AI Code Generation in Ruby
43:35 Future Prospects for Ruby in AI
51:26 Conclusion and Final Thoughts

Send us Fan Mail

In this episode of the Ruby AI Podcast, hosts Joe Leo and his co-host interview Carmine Paolino, the developer behind Ruby LLM. The discussion covers the significant strides and rapid adoption of Ruby LLM since its release, rooted in Paolino's philosophy of building simple, effective, and adaptable tools. The podcast delves into the nuances of upgrading Ruby LLM, its ever-expanding functionality, and the core principles driving its design. Paolino reflects on the personal motivations and community-driven contributions that have propelled the project to over 3.6 million downloads. Key topics include the philosophy of progressive disclosure, the challenges of multi-agent systems in AI, and innovative ways to manage contexts in LLMs. The episode also touches on improving Ruby’s concurrency handling using Async and Rectors, the future of AI app development in Ruby, and practical advice for developers leveraging AI in their applications.

00:00 Introduction and Guest Welcome
00:39 Depend Bot Upgrade Concerns
01:22 Ruby LLM's Success and Philosophy
05:03 Progressive Disclosure and Model Registry
08:32 Challenges with Provider Mechanisms
16:55 Multi-Agent AI Assisted Development
27:09 Understanding Context Limitations in LLMs
28:20 Exploring Context Engineering in Ruby LLM
29:27 Benchmarking and Evaluation in Ruby LLM
30:34 The Role of Agents in Ruby LLM
39:09 The Future of AI Apps with Ruby
39:58 Async and Ruby: Enhancing Performance
45:12 Practical Applications and Challenges
49:01 Conclusion and Final Thoughts

Send us Fan Mail

In this episode of the Ruby AI Podcast, hosts Valentino Stoll and Joe Leo are joined by Avi Flombaum, the founder of Flatiron School. Avi talks about the origins of Flatiron, the success it achieved, and the educational methods used to teach programming, emphasizing on the importance of understanding code deeply and leveraging AI efficiently. He discusses the challenges and changes in the industry, particularly with the rise of AI, and provides insight into modern workflows and product development. The conversation also touches on the necessity of integrating product thinking into engineering and how automated workflows can improve consistency and efficiency in software creation.

00:00 Introduction and Welcoming Avi Flombaum
00:55 Avi's Journey to Founding Flatiron School
02:22 The Impact and Growth of Flatiron School
04:40 Challenges and Evolution in the Bootcamp Industry
05:39 Transitioning from Education to AI
06:39 The Role of AI in Modern Development
08:14 Effective AI Workflows for Developers
16:08 Teaching and Learning with AI
20:47 Product Management and Engineering Collaboration
27:31 Leveraging AI in Product Development
28:35 Exploring AI-Driven Product Development
29:42 Teaching Product Management Skills
30:49 Innovative Solutions in Product Design
32:25 Understanding User Needs and Problem Solving
35:33 Learning Through Code and AI Tools
42:38 The Future of Software Engineering

Send us Fan Mail

In this episode of the Ruby AI Podcast, co-hosts Valentino Stoll and Joe Leo engage in a lively discussion with guest Justin Searls. They explore the evolving landscape of software development with agentic AI tools, comparing traditional agile methodologies with emerging AI-driven practices. Justin Searls his experiences with refactoring and the challenges of integrating AI tools into development workflows. The conversation touches on the suitability of AI in coding, philosophical perspectives on reinforcing proper software practices, and the future potential of these technologies. Justin also provides valuable insights on configuring AI tools for better productivity and discusses his personal coping strategies with the frustrations of modern AI capabilities.

00:00 Introduction and Hosts Banter

00:30 Guest Introduction: Justin Searls

03:13 Justin's Career and Conference Talks

07:52 The Evolution of Agile and Development Practices

16:07 Challenges with AI and Iterative Development

27:47 Recalibrating Development Processes

28:00 Adoption of Pivotal Labs' Methods

28:28 Continuous Integration and Testing

29:21 AI in Development: Current State and Challenges

30:16 The Role of AI Agents in Development

32:17 Frustrations with AI Tools

35:03 Philosophical Reflections on AI in Development

36:16 Generative vs. Subtractive AI

37:06 The Future of AI in Software Development

39:27 Balancing Coding Enjoyment and Productivity

44:02 Capability vs. Suitability in AI Tools

46:35 Prompt Engineering Tips and Tricks

52:39 Closing Thoughts and Plugs

Send us Fan Mail

In this episode of the Ruby AI Podcast, co-hosts Joe Leo and Valentino Stoll, alongside guest Amanda Bizzinotto from Ombu Labs, delve into the ongoing controversy within the Ruby community involving Ruby Central, Shopify, and Bundler/Ruby Gems. While both Valentino and Amanda share their perspectives on the situation, the conversation swiftly transitions into Amanda's journey and current work in AI and machine learning at Ombu Labs. The episode highlights various AI initiatives, including the creation of an AI bot to streamline internal processes, automated Rails upgrade roadmaps, and multi-agent architectures aimed at enhancing efficiency in Rails projects. Amanda also discusses the challenges of integrating AI in consultancy services and shares some insights on the tools and strategies used at Ombu Labs. The podcast concludes with exciting updates about Amanda's recent work, Joe's announcements on upcoming projects including Phoenix's public release, and Valentino's discovery of a new user interface for Claude Swarm.

00:00 Introduction and Welcome

00:26 Ruby Community Controversy

04:37 Amanda's AI Journey

08:45 AI in Business and Consultancy

16:24 AI-Powered Tools and Applications

23:09 Managing Knowledge Base Updates

24:42 Prompting Strategies and Agentic Workflows

26:02 Understanding Workflows vs. Agents

28:37 Observability in AI Systems

29:06 Advanced Prompting Techniques

31:08 Multi-Agent Architectures

34:32 Ruby AI Gems and Libraries

37:09 Exciting Announcements and Future Plans

41:44 Conclusion and Final Thoughts

Mentioned In The Show:

• AI for Rails upgrades: FastRuby automated roadmap
• PGVector and Neighbor gem
• Guardrails.ai for hallucination control (https://www.guardrailsai.com)
• Microsoft Presidio for PII stripping
• Observability with LangFuse (https://www.langfuse.com)
• Prompting engineering techniques
• Chain-of-Thought, ReAct pattern article 
• ActiveAgent
• LangChain.rb
• DSPy.rb
• Phoenix AI upgrade assistant public beta Oct 15 event
• Ombu Labs roadmap tool live now
• Swarm UI for Claude Swarm by Parruda 
• Ombu Labs – https://ombulabs.com
• Artificial Ruby NYC meetup – https://artificialruby.ai
• Shopify Claude Swarm project – https://github.com/shopify/claude-swarm

Send us Fan Mail

In this episode, Valentino Stoll and Joe Leo unpack the widening gap between headline-grabbing AI salaries and the day-to-day realities of building sustainable AI products. From sports-style contracts stuffed with equity to the true cost of running large models, they explore why incremental gains often matter more than hype. The conversation dives into the messy art of benchmarking LLMs, the fresh evaluation tools emerging in the Ruby ecosystem, and new OpenAI features that change how prompts, tools, and reasoning tokens are handled. Along the way, they weigh the business math of switching models, debate standardisation versus playful experimentation in Ruby, and highlight frameworks like RubyLLM, Phoenix, and Leva that are reshaping how developers ship AI features.

Takeaways

• The importance of marketing oneself in the tech industry.
• Disparity in AI salaries reflects market demand and hype.
• AI contracts often include equity, complicating true value assessment.
• The AI race lacks clear winners, with incremental improvements across models.
• User experience often outweighs model efficacy in AI products.
• Prompt engineering is crucial for optimizing model performance.
• Benchmarking AI models is complex and requires tailored evaluation sets.
• Existing tools for AI evaluation are often insufficient for specific needs.
• Cost analysis is critical when choosing AI models for business.
• Incremental improvements in AI models may not meet user expectations. You can constrain tool outputs to specific grammars for flexibility.
• Asking models to think out loud can enhance tool calls.
• Reasoning tokens can be reused in subsequent AI calls.
• Evaluating AI frameworks is crucial for business decisions.
• Ruby's integration in AI is becoming more prominent.
• The AI landscape is rapidly evolving, requiring adaptability.
• Hype cycles can mislead developers about tool longevity.
• Ruby offers a unique user experience for developers.
• Tinkering with code fosters creativity and innovation.
• The playful nature of Ruby can lead to unexpected insights.

Send us Fan Mail

Veteran Rubyist and investor Chad Fowler sits down with hosts Valentino Stoll and Joe Leo to unpack why generative AI is less a magic trick and more the next big layer of abstraction. From his days rewriting Wunderlist in multiple languages to today’s LLM-driven code generation, Chad explains how small, well-typed modules, strong conventions and agent-based workflows could let humans design systems while machines write the code. The trio debate Python vs. Ruby, micro-services vs. monoliths, cognitive load, runtime performance (hello Haskell & Rust) and what it will take for legacy Rails apps—and our careers—to thrive in an AI-first future.

Mentioned In the Show:

• MountainWest Ruby Conference — Early Ruby conference where Chad delivered a keynote in 2007 about the future of Ruby. 
• TLA+ — Formal specification language for verifying distributed systems, discussed in relation to formal verification.
• Quint Language — Open-source formal specification language resembling Ruby/JavaScript.
• OWL (Web Ontology Language) — Semantic Web language for defining ontologies, cited as inspiration for constraints.
• Extreme Programming Immersion (Object Mentor) — XP training course Chad attended, pairing with Kent Beck.
• Immutable Infrastructure — Concept Chad advocated, paired with his idea of "disposable code."
• Snyk — Security company that auto-generates PRs for dependency and vulnerability fixes, discussed as a precursor to agent workflows.
• Specification-Driven Development — You described industry momentum toward specification-driven code assistants.
• Claude on Rails — Obie's exploration of using Anthropic's Claude with Ruby on Rails.
• ESP32 Dev Kit — IoT hardware Chad experimented with, used in AI-assisted electronics projects.
• 3D Printing with ChatGPT — General reference to AI-assisted 3D design and printing workflows.

Send us Fan Mail

In this episode of the Ruby AI Podcast, host Valentino Stoll talks with special guest Kieran, a prominent figure in the Ruby AI space. Kieran recently gave a talk at the San Francisco Ruby Meetup about his new gem, Leva, which focuses on LLM evaluations in Ruby. Kieran discusses his background, his passion for AI and Ruby, as well as his journey in building AI products, including his tool Cora, which helps manage email inboxes by categorizing and summarizing emails using AI. Together, Valentino and Kieran explore the process, challenges, and best practices of creating AI-driven gems and tools in Ruby, the importance of evaluations, and the fun and creative aspects of integrating AI into Ruby on Rails projects.

Mentioned in the show:

• Kieran Klaassen – Ruby developer, creator of Cora and Leva.
• Leva gem – Kieran's LLM evaluation framework for Rails.
• Jumpstart Pro – “is the best Ruby on Rails SaaS template out there”.
• Stepper / Stepper Motor (workflow engine) – a “journey” with steps for background jobs.
• Jaccard Index – A metric for set similarity (|A∩B|/|A∪B|).
• LangSmith – a platform for building production-grade LLM applications.
• Morph LLM – The Fastest Way to Apply AI Edits (4500+ tokens/sec).
• Friday AI Agent – An AI-powered coding agent that handles PRs from start to finish.
• DSPy.rb – Framework for building AI agents and optimizing prompts.

Highlights:

00:00 Introduction and Guest Welcome

00:53 Kieran's Background and AI Journey

01:20 Building AI Tools and the Leva Gem

03:47 Challenges and Best Practices in AI Development

07:16 Evaluations and Real-World Applications

07:36 Community Recognition and Adoption

12:37 Prompt Engineering and Model Testing

22:06 Leveraging AI for Workflow Optimization

28:35 Visualizing Workflows and Tools

31:44 Exploring Hybrid Orchestration Layers

33:15 Debating Deterministic Workflows vs. Agent Flows

34:28 The Fun of Experimenting with AI and Ruby

34:55 Building Gems and Learning Through Creation

40:03 The Value of Rails in AI Development

46:28 Evaluating AI Outputs and Metrics

50:40 Annotation and Continuous Improvement

53:50 Future of AI and Rails Integration

54:54 Closing Thoughts and Recommendations

Send us Fan Mail

Ruby legend Obie Fernandez joins hosts Valentino Stoll and Joe Leo to unveil Roast—the new open-source Ruby framework for declaring reliable AI workflows—and celebrate the 1.0 release of its engine library, Raix. The trio dig into agent swarms, prompt-engineering best practices, code-base refactors, and why unleashing creativity matters more than ever in an AI-driven future."

Show Notes

• Obie’s book — https://leanpub.com/patterns-of-application-development-using-ai
• Roast (GitHub) — https://github.com/Shopify/roast
• Roast (intro post) — https://shopify.engineering/introducing-roast
• Raix (core library) — https://github.com/OlympiaAI/raix
• Raix for Rails — https://github.com/OlympiaAI/raix-rails
• Claude Swarm (multi-agent YAML swarms) — https://github.com/parruda/claude-swarm
• Claude Squad https://github.com/smtg-ai/claude-squad
• Claude Code (agentic coding tool) — https://www.anthropic.com/claude-code
• Claude Opus (model family) — https://www.anthropic.com/claude
• “Software 3.0” (Karpathy talk) — https://www.youtube.com/watch?v=LCEmiRjPEtQ
• Suno (AI music) — https://suno.com/
• Olympia (AI team platform) — https://olympia.chat/
• “The Bitter Lesson” (R. Sutton) — https://www.incompleteideas.net/IncIdeas/BitterLesson.html
• POODR (Sandi Metz) — https://www.poodr.com/
• Refactoring (Martin Fowler) — https://martinfowler.com/books/refactoring.html
• Clean Code (R.C. Martin) — https://www.informit.com/store/clean-code-a-handbook-of-agile-software-craftsmanship-9780135398579

Hosts & Guest on Social
@thecodenamev
@jleo3
@obie

Send us Fan Mail

Seventeen-year Ruby veteran Justin Bowen joins hosts Valentino Stoll and Joe Leo to unveil Active Agent—a Rails-native framework that treats every agent like a controller and every prompt like a view, letting you weave LLMs, vector search, and business logic straight into MVC.

The crew also digs into the real-world mechanics of shipping AI: defining ground-truth datasets, replay-ready evaluation harnesses, and tight retry logic that keeps hallucinations out of production. You’ll hear a candid take on the current hype cycle (and its parallels to crypto), the challenges of long-term gem maintenance, and fresh ways to keep open-source sustainable—think GitHub Sponsors, corporate grants, and pro-tier gems.

What you’ll hear

• Active Agent 101 – agents as abstract controllers, templated prompts as views
• Testing in the wild – fingerprints, VCR cassettes & CI pipelines for non-deterministic code
• Context is king – why ground truth matters when counting cows or parsing legal docs
• OSS meets ROI – balancing passion projects with sustainable monetisation
• Rails vs. Python/Next.js – reclaiming the one-person startup stack
• Community fuel – Discords, hackathons, and the push for academic & corporate sponsorship

Mentioned In The Show:

• Active Agent (GitHub)  – Justin’s Rails-native, agent-oriented framework for building AI features.
•  Vercel AI SDK  – TypeScript toolkit whose generative-UI ideas helped inspire Active Agent.
•  Maestra.ai  – YC W24 startup offering AI transcription, dubbing, and hosted agent runtimes.
• Matz's 2025 Ruby Kaigi AI Keynote
•  ONNX Runtime Ruby  – Gem that runs ONNX models (CPU/GPU) from Ruby.
•  PGVector gem  – Ruby bindings for PostgreSQL’s pgvector extension (embeddings storage).
•  Neighbor gem  – k-NN / ANN vector search for Rails & Postgres—pairs nicely with PGVector.
• Hugging Face JS – Run models in the browser with WebGPU and ONNX 
•  Hugging Face Spaces  – No-config platform for hosting ML demos; handy for sharing agent prototypes.
•  LangSmith (LangChain)  – Evaluation & observability service discussed as a monetization model.
•  CrewAI (GitHub)  – Python framework for orchestrating multi-agent “crews”; Joe’s current go-to.
•  Honeybadger  – Rails-first error-monitoring SaaS—an inspiration for future Active Agent services.
• Rising Impact – A Netflix anime special about a third-grader's journey to be the world's best golfer.
•  Osmo AI  – Google-born startup using AI to digitise smell—cited in the show’s “AI hype” chat.
•  Ruby AI Builders Discord  – Public Discord community for Rubyists building AI apps.