The Ruby AI Podcast

What happens when you treat an AI agent like a co-founder instead of a tool?In this episode, Valentino and Joe go deep into a real-world experiment: spinning up an autonomous agent using OpenClaw, giving it domains, goals, and just enough guidance to build an actual business. From creating accounts and managing projects to writing code, deploying with Kamal, and even designing its own training curriculum, the agent evolves from confused assistant to something resembling a junior engineer with initiative.Along the way, they explore the messy reality of agent workflows: memory systems, self-training loops, PR reviews, hallucinated confidence, and the constant tension between autonomy and control. The result? A working product, 15 early users, and a pile of hard-earned lessons about what AI can and definitely cannot do today.If you’re building with agents, thinking about autonomous systems, or just curious what happens when you let AI run a startup… this one’s for you.🔗 Show Notes- Valentino's Minerva Experiment- Minerva's First ProductCore Tools & Frameworks- RubyLLM (Carmine Paolino)- Kamal (Deploy Rails anywhere)- Tailscale (Secure networking)Libraries & Infra Mentioned- ExtraLite (SQLite performance layer)Learning & Community- Ruby AI Newsletter (Matt Solt)Other Mentions- OpenClaw- Claude Code- Action MCP- Fizzy (37signals)- Magic Beans (graph-based project management for agents)- ups.dev (agent status pages project)- DailyVibe.aiBooks & Resources Referenced- Practical Object-Oriented Design in Ruby by Sandi Metz- Programming Ruby (Pickaxe Book)- The Well-Grounded Rubyist- Layered Design for Ruby on Rails Applications — Vladimir DementyevCultural Reference- Wired article on AI-generated band marketing (“Geese”)00:00 Podcast kickoff00:40 Geese AI marketing psyop02:03 Starting an AI band04:18 Daily Vibe artist generator06:24 Open Claw origin story08:52 Domains to business ideas10:44 Onboarding an AI coworker13:22 Handholding and action loops14:10 Shark Tank idea filter15:32 Training and memory system20:20 UPS dev agent status pages22:54 Rails build struggles24:04 Bootcamp with Ruby books26:20 Rebuild MVP and open source27:55 Deploying with EC228:38 Locking Down Access30:06 AI PR Reviews32:50 Self QA Automation36:11 Fixing Agent Memory38:15 Email and Token Costs40:11 Heartbeats and Delegation43:01 Customer Discovery Lessons44:49 Selling Workflow Friction48:19 Knowledge Base Frameworks51:37 Open Source Model Future53:57 Security Agents and Wrap

Valentino Stoll and co-host Joe Leo open the Ruby Podcast noting OpenAI is winding down its SOA video app and discuss the broader difficulty of building AI businesses. Guest Bekki Freeman, staff software engineer at Caribou Financial and organizer of Rocky Mountain Ruby, shares conference details (Boulder, Colorado at eTown, September 28–29; CFP opening soon; tickets after the schedule). The conversation focuses on safely scaling AI use in an 8-year Rails monolith: preparing messy codebases with dead code and metaprogramming, strengthening test harnesses and coverage, improving documentation, and being explicit about desired patterns rather than copying existing bad ones. They discuss PR review bottlenecks from increased AI-generated PRs, ideas like specialized AI review agents, stronger RuboCop rules, pairing/mobbing, and remote knowledge-sharing practices, plus security cautions and what AI may and may not replace (tech-debt work vs “taste”).00:00 Sora Shutdown News00:57 AI Hype Reality Check01:43 Meet Bekki Freeman02:00 Rocky Mountain Ruby Update04:32 AI Meets Legacy Rails07:22 Prep Codebase for AI10:06 Patterns Versus Best Practices12:37 Testing Strategy and TDD16:45 PR Review Bottlenecks19:27 Specialized Review Agents21:31 Defining Quality Context24:29 Humans and Team Adoption25:20 Remote Change Adoption27:00 Creating Sharing Rituals29:19 Release Calls As Watercooler30:12 Mob Sessions With Agents33:55 Security And YOLO Risks35:45 Too Much Code Problem37:16 Vibe Coding Vs SaaS42:10 AI Engineering In Two Years45:33 Codex Versus Claude47:39 Wrap Up And Farewell

On the Ruby AI Podcast, hosts Valentino and Joe Leo welcome Scholarly CTO/co-founder Kelly Sutton to discuss building a vertical SaaS “faculty information system” for universities. Sutton explains why competitors can’t easily replicate Scholarly: higher ed is moving off decades-old homegrown software, and the product must meet trust, security, compliance, and regulatory demands such as SOC 2 Type II. He describes how Scholarly expanded from replacing Excel/Access tracking to sophisticated workflow automation and how universities recently shifted from AI skepticism to AI FOMO. Scholarly uses AI in product surfaces, heavily in engineering, and via an admin MCP server that helps ops/customer success rapidly configure workflows from faculty handbooks with human-in-the-loop review. The conversation debates MCP’s likely temporariness versus traditional APIs, emphasizes smaller reviewable “PR-sized” outputs, and frames AI as an implementation detail focused on customer value. Valentino also shares an experiment training Claude to build products, including ups.dev and an open-source Ruby uptime-monitoring gem.

Many “AI startups” today are little more than thin wrappers around large language model APIs. But what happens when those APIs improve and the platforms absorb those features?In this episode of The Ruby AI Podcast, Valentino Stoll and Joe talk with builder and investor Thomas Witt, founder of Vendis.ai and operator of the pre-seed firm Expedite Ventures. Thomas shares why he believes the next generation of durable companies must deliver real value deep in the product stack rather than bolting chat onto existing software.The conversation explores why traditional CRMs are widely disliked and how an AI-native CRM might look completely different. Instead of rigid forms and required fields, Thomas describes a system where conversations themselves become the primary data source. Emails, meetings, and messages are embedded, searched semantically, and transformed into structured knowledge automatically.They also dive into the architecture required to support this shift. From Ruby on Rails and Hotwire to DynamoDB, vector search, async Ruby, and multi-model LLM workflows, Thomas shares practical lessons from building AI-heavy production systems.Along the way the discussion touches on agentic coding workflows, LLM-as-a-judge evaluation patterns, telemetry for prompt chains, and why small teams may soon replace the massive engineering orgs we’ve grown used to.If you’re curious where Ruby, Rails, and AI systems are heading next, this conversation offers a fascinating glimpse.Show NotesGuest: Thomas Witt Founder of Vendis.ai Investor at Expedite VenturesTopics we explore• Why many AI startups are just “wrappers” around LLM APIs • What an AI-native CRM looks like when conversations become the database • Why Thomas chose Ruby on Rails with minimal JavaScript using Hotwire and Stimulus • Using Amazon DynamoDB instead of relational databases for AI workloads • Hybrid keyword + vector search with OpenSearch and Elasticsearch • Async Ruby patterns using fibers, the Async ecosystem, and the Falcon web server • Orchestrating many concurrent LLM calls within a single user interaction • Background job systems and queues such as Amazon SQS • Code quality workflows with StandardRB and RuboCop • Using models like Claude, OpenAI Codex, and Gemini together in multi-model workflows • Observability and prompt tracing with Langfuse • Why AI tooling may enable much smaller engineering teamsMentioned in the Show• Vendis.ai – Thomas’s AI-native CRM platform • Hotwire – HTML-over-the-wire approach for modern Rails apps • Falcon – Fiber-based Ruby web server • Ruby AI Builders Discord – Community of Ruby developers building AI tools • Chaos to the Rescue @ Artificial Ruby

In this episode of the Ruby AI Podcast, hosts Joe and Valentino welcome special guest, Kinsey Durham Grace, a prominent figure in the Ruby community and member of the GitHub team. The discussion covers a range of topics including the use of AI for generating episode artwork, the application of AI agents in coding tasks, and the recent developments at GitHub like the Agent HQ. Kinsey shares insights into her day-to-day work on the coding agent core team at GitHub, including the use of custom agents to enhance coding efficiency. They also delve into the impact of AI on software development, the importance of well-rounded developer skills, and Kinsey’s perspective on the future of Ruby in the AI landscape.00:00 Introduction and Guest Welcome00:30 AI-Generated Images and Their Drawbacks03:07 Kinsey's Role at GitHub06:33 Using AI Tools in Development11:26 Challenges in Large Monolith Apps18:23 Modular and Maintainable Agents24:47 AI's Role in Software Development25:29 Challenges with Current AI Tools26:50 Observational Memory in AI27:42 Open Claw and Heartbeat Concepts28:22 Collaborative AI and Future Prospects29:22 In-House vs. Third-Party Observability Tools29:54 New AI Products and Intent Capture31:08 Persisting Context in Software Development37:42 Custom Agents and Knowledge Management46:13 The Human Element in AI Collaboration47:20 Skills for the Future of AI in Engineering48:54 Ruby and AI: Staying Relevant50:50 Conclusion and Final Thoughts🔗 Resources Mentioned in This EpisodeKinsey’s talk at RailsWorld 2025: The Rise of the Agents In RailsGitHub & Agent Workflowshttps://github.comhttps://github.com/features/copilothttps://github.bloghttps://cli.github.comhttps://code.visualstudio.comhttps://github.com/features/codespacesModels & AI Tools Mentionedhttps://claude.aihttps://www.anthropic.comhttps://openai.comhttps://platform.openai.comhttps://gemini.google.comhttps://cursor.shhttps://ampcode.comObservability & Infrastructurehttps://www.datadoghq.comhttps://learn.microsoft.com/en-us/azure/data-explorer/kusto/query/OpenClawhttps://openclaw.aihttps://github.com/OpenClawMastra AIhttps://mastra.aiQMD (Referenced by Valentino)https://github.com/tobi/qmdStephen Margheim – SQLite / Ruby Workhttps://fractaledmind.github.iohttps://github.com/digital-fabric/extraliteGitHub-Related Announcements (Former CEO Mention)https://entire.io/

In this episode of the Ruby AI Podcast, hosts Valentino Stoll and Joe Leo are joined by Ben Schofield, an accomplished author, open source contributor, and Ruby enthusiast. The discussion starts with thoughts on the upcoming RubyConf and the unique experience of conferences hosted in Las Vegas. Ben shares his recent experiences with Bento and the impact of layoffs. The conversation delves deep into the nature of expertise, exploring questions around achieving world-class performance and domain-specific skills. The hosts explore the goals of software development, the role of AI in coding, and the importance of intentionality in using agents. They also touch on the concept of default settings in development, the nuances of staff engineering, and strategies for training future staff engineers. The discussion concludes with ideas for improving the onboarding and training of engineers in the evolving landscape of AI tools.Mentioned in this episode:RubyConf 2026 (Las Vegas)RailsConf (context/history)O’Reilly (RailsConf partner mentioned historically)Bento (Ben’s recent company)Gusto (host context)Artificial Ruby / Ruby x AI NYC meetupsAgentic coding & toolingClaude Code docsClaude Code + MCPBooks, papers, and ideasC. Thi Nguyen (background)Games: Agency as Art (Oxford)Ezra Klein Show episode (Nguyen)Malcolm Gladwell, OutliersAndy Hunt, Pragmatic Thinking and Learning (Refactor Your Wetware)Ericsson et al. (1993) deliberate practice (DOI)Macnamara & Maitra replication (2019) (DOI)David Epstein, RangeWill Larson, Staff EngineerRobert Cialdini, Influence resourcesDHH on conceptual compressionChad Fowler, The Phoenix Architecture (Leaflet)Quote referenced (“How can I know what I think till I see what I say?”)Ruby/Rails primitives referenced in Valentino's experimentsRuby method_missingRuby define_methodRails rescue_fromValentino's experimental Ruby project (“Chaos to the Rescue”) that uses LLMs + runtime method definition

Ruby turns 30, Ruby 4 quietly ships, and the AI tooling arms race shows signs of maturity. Valentino and Joe unpack what stability really means for a language in its third decade, debate agent-driven development, AI “slop,” binary distribution, and whether open source incentives are breaking down—or simply evolving.Mentioned In The ShowA grab-bag of tools, projects, and references Valentino & Joe brought up.Ruby & Core EcosystemRuby Gets A Fresh Look — Official Ruby programming language site (news, downloads, docs) now with a great new look.  Ruby Kaigi — Ruby’s flagship conference (talks, schedules, archives). Bundler — Ruby dependency manager used across the ecosystem.AI Coding ToolsClaude Code — Anthropic’s CLI coding assistant workflow discussed heavily in the episode.OpenAI Codex — OpenAI’s coding agent/tooling referenced as an alternative workflow.Ruby Web Frameworks & ArchitectureRails Framework — Ruby on Rails, referenced as the default baseline for many apps.Jumpstart Rails — Rails starter kits/templates mentioned as a “pick a Rails” approach.Roda Framework — Jeremy Evans’ web toolkit (lighter than Rails, bigger than Sinatra).dry-rb Suite — Ruby gems for functional-ish architecture and explicit business logic.Trailblazer — High-level architecture for operations, workflows, and domain logic.Quality, Testing, and PracticeBetter Specs — Community-curated RSpec guidelines mentioned as a spec style target.Datadog — Error monitoring referenced in the “well-defined bug + stack trace” workflow.Open Source SustainabilityGitHub Sponsors — Sponsorship mechanism discussed as one (partial) monetization path.People MentionedSandi Metz — Referenced as the “code whisperer” ideal for idiomatic Ruby guidance.

In this episode of the Ruby AI podcast, hosts Valentino Stoll and Joe Leo engage with Evan Phoenix, a seasoned Ruby programmer and CEO of Mirren. The conversation explores Evan's unique name origin, his career trajectory, and the integration of AI in development workflows. They discuss the distinction between real and fake AI in products, the impact of AI on engineering practices, and the future of AI in development tools. Evan shares insights on performance optimization, human-centric AI interactions, and the role of AI in deployment and architecture detection. In this conversation, Joe, Evan Phoenix, and Valentino Stoll discuss the evolving landscape of software development, particularly focusing on the role of AI, automation, and the Ruby programming language. They explore how AI can assist in analyzing code bases, the future of development with ambient agents, and the potential resurgence of monolithic architectures. The discussion also touches on the importance of human-centric design in software, the significance of experimentation, and the unique strengths of Ruby in the current tech environment. The conversation concludes with predictions about the future of small teams in software development and the impact of AI on coding practices.

In this episode of the Ruby AI Podcast, hosts Valentino Stoll and Joe Leowelcome AI and Ruby expert Chris Hasinski. They delve into the benefits andchallenges of self-hosting AI models, including control over model updates, costconsiderations, and the ability to fine-tune models. Chris shares his journeyfrom machine learning at UC Davis to his extensive work in AI and Ruby, touchingupon his contributions to open source projects and the Ruby AI community. Thediscussion 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 andsoftware development, this episode offers valuable insights and practicaladvice.00:00 Introduction and Guest Welcome00:31 Why Self-Host Models?01:28 Challenges and Benefits of Self-Hosting03:14 Chris's Background in Machine Learning04:13 Applications Beyond Text06:39 Fine-Tuning Models12:27 Ruby in Machine Learning16:06 Distributed Training and Model Porting18:22 Choosing and Deploying Models25:19 Testing and Data Engineering in Ruby27:56 Database Naming Conventions in Different Languages28:19 Importance of Data Quality for AI18:03 Monitoring Locally Hosted AI Models29:37 Challenges with LLMs and Performance Tracking31:09 Improving Developer Experience in Ruby31:45 Ruby's Ecosystem for Machine Learning32:43 The Need for Investment in Ruby's AI Tools38:25 Challenges with AI Code Generation in Ruby43:35 Future Prospects for Ruby in AI51:26 Conclusion and Final Thoughts

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 Welcome00:39 Depend Bot Upgrade Concerns01:22 Ruby LLM's Success and Philosophy05:03 Progressive Disclosure and Model Registry08:32 Challenges with Provider Mechanisms16:55 Multi-Agent AI Assisted Development27:09 Understanding Context Limitations in LLMs28:20 Exploring Context Engineering in Ruby LLM29:27 Benchmarking and Evaluation in Ruby LLM30:34 The Role of Agents in Ruby LLM39:09 The Future of AI Apps with Ruby39:58 Async and Ruby: Enhancing Performance45:12 Practical Applications and Challenges49:01 Conclusion and Final Thoughts

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 Flombaum00:55 Avi's Journey to Founding Flatiron School02:22 The Impact and Growth of Flatiron School04:40 Challenges and Evolution in the Bootcamp Industry05:39 Transitioning from Education to AI06:39 The Role of AI in Modern Development08:14 Effective AI Workflows for Developers16:08 Teaching and Learning with AI20:47 Product Management and Engineering Collaboration27:31 Leveraging AI in Product Development28:35 Exploring AI-Driven Product Development29:42 Teaching Product Management Skills30:49 Innovative Solutions in Product Design32:25 Understanding User Needs and Problem Solving35:33 Learning Through Code and AI Tools42:38 The Future of Software Engineering

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 Banter00:30 Guest Introduction: Justin Searls03:13 Justin's Career and Conference Talks07:52 The Evolution of Agile and Development Practices16:07 Challenges with AI and Iterative Development27:47 Recalibrating Development Processes28:00 Adoption of Pivotal Labs' Methods28:28 Continuous Integration and Testing29:21 AI in Development: Current State and Challenges30:16 The Role of AI Agents in Development32:17 Frustrations with AI Tools35:03 Philosophical Reflections on AI in Development36:16 Generative vs. Subtractive AI37:06 The Future of AI in Software Development39:27 Balancing Coding Enjoyment and Productivity44:02 Capability vs. Suitability in AI Tools46:35 Prompt Engineering Tips and Tricks52:39 Closing Thoughts and Plugs

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 Welcome00:26 Ruby Community Controversy04:37 Amanda's AI Journey08:45 AI in Business and Consultancy16:24 AI-Powered Tools and Applications23:09 Managing Knowledge Base Updates24:42 Prompting Strategies and Agentic Workflows26:02 Understanding Workflows vs. Agents28:37 Observability in AI Systems29:06 Advanced Prompting Techniques31:08 Multi-Agent Architectures34:32 Ruby AI Gems and Libraries37:09 Exciting Announcements and Future Plans41:44 Conclusion and Final ThoughtsMentioned In The Show:AI for Rails upgrades: FastRuby automated roadmapPGVector and Neighbor gemGuardrails.ai for hallucination control (https://www.guardrailsai.com)Microsoft Presidio for PII strippingObservability with LangFuse (https://www.langfuse.com)Prompting engineering techniquesChain-of-Thought, ReAct pattern article ActiveAgentLangChain.rbDSPy.rbPhoenix AI upgrade assistant public beta Oct 15 eventOmbu Labs roadmap tool live nowSwarm UI for Claude Swarm by Parruda Ombu Labs – https://ombulabs.comArtificial Ruby NYC meetup – https://artificialruby.aiShopify Claude Swarm project – https://github.com/shopify/claude-swarm

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.TakeawaysThe 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.

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.

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 Welcome00:53 Kieran's Background and AI Journey01:20 Building AI Tools and the Leva Gem03:47 Challenges and Best Practices in AI Development07:16 Evaluations and Real-World Applications07:36 Community Recognition and Adoption12:37 Prompt Engineering and Model Testing22:06 Leveraging AI for Workflow Optimization28:35 Visualizing Workflows and Tools31:44 Exploring Hybrid Orchestration Layers33:15 Debating Deterministic Workflows vs. Agent Flows34:28 The Fun of Experimenting with AI and Ruby34:55 Building Gems and Learning Through Creation40:03 The Value of Rails in AI Development46:28 Evaluating AI Outputs and Metrics50:40 Annotation and Continuous Improvement53:50 Future of AI and Rails Integration54:54 Closing Thoughts and Recommendations

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 NotesObie’s book — https://leanpub.com/patterns-of-application-development-using-aiRoast (GitHub) — https://github.com/Shopify/roastRoast (intro post) — https://shopify.engineering/introducing-roastRaix (core library) — https://github.com/OlympiaAI/raixRaix for Rails — https://github.com/OlympiaAI/raix-railsClaude Swarm (multi-agent YAML swarms) — https://github.com/parruda/claude-swarmClaude Squad https://github.com/smtg-ai/claude-squadClaude Code (agentic coding tool) — https://www.anthropic.com/claude-codeClaude Opus (model family) — https://www.anthropic.com/claude“Software 3.0” (Karpathy talk) — https://www.youtube.com/watch?v=LCEmiRjPEtQSuno (AI music) — https://suno.com/Olympia (AI team platform) — https://olympia.chat/“The Bitter Lesson” (R. Sutton) — https://www.incompleteideas.net/IncIdeas/BitterLesson.htmlPOODR (Sandi Metz) — https://www.poodr.com/Refactoring (Martin Fowler) — https://martinfowler.com/books/refactoring.htmlClean Code (R.C. Martin) — https://www.informit.com/store/clean-code-a-handbook-of-agile-software-craftsmanship-9780135398579Hosts & Guest on Social @thecodenamev @jleo3 @obie

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 hearActive Agent 101 – agents as abstract controllers, templated prompts as viewsTesting in the wild – fingerprints, VCR cassettes & CI pipelines for non-deterministic codeContext is king – why ground truth matters when counting cows or parsing legal docsOSS meets ROI – balancing passion projects with sustainable monetisationRails vs. Python/Next.js – reclaiming the one-person startup stackCommunity fuel – Discords, hackathons, and the push for academic & corporate sponsorshipMentioned 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.

Scott Werner—author of the Works on My Machine newsletter and creator of the Sublayer AI-agent framework—joins Valentino and Joe for a fast-moving conversation on how Rubyists are bending large-language models to their will. We unpack Sublayer’s “generators + actions” architecture, the delightfully chaotic Monkey’s Paw prompt-driven web framework, and Phoenix’s AI-generated test suites, all while debating what remains uniquely human in an age of code that writes itself. If you care about Ruby, rapid prototyping, and staying sane as models ship weekly, this one’s for you.Show NotesMeet Scott Werner – from early Rails days to Works on My Machine and the Artificial Ruby meetup scene. Inside Sublayer – why “string-in → string-out” thinking led to Generators, Actions, and the idea of promptable architecture for code that assembles itself.Monkey’s Paw – a Ruby gem where Markdown “wishes” become full web pages via an LLM—hallucinations welcome.Blueprints & Semantic Linting – templated agent blueprints now built into Sublayer and text-based rules that keep AI code reviews on-message.Phoenix.love – Joe’s Rails-centric tool that churns out thousands of AI-generated tests and the ops pain (alerts, idle “vibe-waiting”) that follows.Feedback Loops & Human Taste – why Paul McCartney’s Get Back jam session is the right metaphor for iterating with an LLM collaborator. When the Model Eats Your Product – surviving weekly model upgrades, function-calling APIs, and the temptation to rebuild everything (again).Ruby’s Next Act – AI-inspired namespacing proposals, Ractors explained, and why dynamic languages still win the “unknown unknowns.”Show-and-Tell PicksScott: TLDraw for visual AI pipelines. Valentino: “AI Software Architect” markdown blue-prints. Joe: “Demystifying Ruby” blog series on threads, fibers & ractors. Referenced URLsSublayer – https://sublayer.comSublayer (GitHub) – https://github.com/sublayerapp/sublayerMonkey’s Paw (GitHub) – https://github.com/sublayerapp/monkeyspawPhoenix – https://phoenix.loveWorks on My Machine newsletter – https://worksonmymachine.substack.comTLDraw – https://tldraw.com---00:00 Introduction to Ruby and AI02:04 Scott's Journey with Ruby and AI04:41 The Evolution of Programming Languages06:38 The Ruby Community's Impact on Software Engineering08:43 Monkey's Paw: A New Approach to Web Development10:35 AI's Role in Creative Processes11:30 Collaboration with AI in Software Development14:50 The Future of Software Development17:24 The Impact of AI on Customer Feedback20:24 Navigating the Rapid Changes in Software Products22:51 Understanding User Feedback in AI Development24:53 The Human Element in AI Collaboration28:20 Prototyping with AI Tools30:18 The Evolving Roles in Teams31:43 Sublayer Tech: Innovations and Frameworks34:36 Blueprints and Code Generation37:14 Navigating Existential Dread in AI Development40:15 The Future of AI and Product Development44:12 Community and Collaboration in Tech47:08 Monitoring AI Processes50:19 The Importance of Orchestration52:03 Final Thoughts and Recommendations

Valentino Stoll and co-host Joe Leo kick off The Ruby AI Podcast with a candid deep-dive into what it really takes to ship AI-powered products in Ruby today. From the origin story of Joe’s test-writing automation platform Phoenix to the surge of new Ruby-first agent libraries, the duo explore why the community is approaching a tipping point, how to escape “chat-bot-only” thinking, and where reactive, evaluation-driven tooling is headed next. Along the way they trade war stories about semver mishaps, code-review “LLM tells,” and the projects, meet-ups, and conferences that keep the Ruby-AI scene buzzing.TakeawaysThe Ruby AI community is growing and offers valuable networking opportunities.Ruby's syntax is well-suited for AI applications, making it a fun choice for developers.Generative AI tools can increase productivity but also add cognitive burden to developers.The integration of AI tools in Ruby applications presents unique challenges.Developers are relearning how to program with the advent of generative AI.AI frameworks are evolving, and Ruby developers need to stay updated.The importance of evaluating AI tools and their effectiveness in real-world applications.Ruby's flexibility allows for creative solutions in AI development.The future of AI in software development will require continuous adaptation.Emerging AI frameworks in Ruby are promising but require careful evaluation. Referenced In The ShowPhoenix by DefMethod – https://www.phoenix.love/OpenAI Ruby SDK – https://github.com/openai/openai-rubySublayer – https://github.com/sublayerapp/sublayerCrewAI – https://github.com/crewAIInc/crewAIActive Agent – https://github.com/activeagents/activeagentRaix – https://github.com/OlympiaAI/raixShopify Roast – https://github.com/Shopify/roastLangChain.rb – https://github.com/patterns-ai-core/langchainrbHugging Face smolagents – https://huggingface.co/docs/smolagents/indexBuilding Code Agents with Hugging Face smolagents – https://www.deeplearning.ai/short-courses/building-code-agents-with-hugging-face-smolagents/V's side project, NowReading.dev – https://nowreading.dev

In this episode of the Ruby AI podcast, hosts Landon and Valentino discuss the exciting developments in the Ruby AI community. They explore three key gems: Ruby OpenAI, Raix, and Langchain.rb, highlighting their features, use cases, and the importance of evaluation methodologies like RAGAS in AI systems. The conversation emphasizes the collaborative spirit of the Ruby AI community and the potential for innovation in AI applications using Ruby.TakeawaysThe Ruby AI community is vibrant and growing.Ruby OpenAI is essential for integrating OpenAI's capabilities.Raix gem offers an object-oriented approach to AI in Ruby.Langchain RB normalizes AI provider integrations in Ruby.RAGAS provides a framework for evaluating AI outputs.Community engagement is crucial for Ruby AI's growth.Documentation is key for developers using these gems.Collaboration among developers enhances innovation.AI systems require robust evaluation methodologies.Ruby is at the forefront of AI development.Sound Bites"This is gonna be really exciting.""Join the Ruby AI Builders Discord.""There's so much cool stuff out there."