December 17, 2025
Metaprogramming has always been one of Ruby’s most powerful — and most intimidating — features. While the book Metaprogramming Ruby by Paolo Perrotta is widely regarded as a classic, many developers share the same experience: it’s brilliant, but hard to truly internalize by just reading it.
In a talk presented at RubyWorld Conference 2025, Shinichi Maeshima (kinoppyd) shared a compelling story of how this challenge was addressed in practice — by transforming the book into a living, evolving set of hands-on challenges that scale across teams, companies, and even the global Ruby community.
This presentation is not about metaprogramming techniques themselves, but about how to teach, practice, and retain deep Ruby knowledge effectively.
The Core Problem: Reading Is Not Enough
The starting point is familiar to many Ruby teams:
- Metaprogramming Ruby is a must-read, but dense.
- Group reading sessions are difficult to run consistently.
- Knowledge fades when it’s not applied.
- Onboarding new developers repeatedly is costly and does not scale.
At SmartHR, Maeshima and his colleagues wanted more than a reading group. They wanted a system that would:
- Build real competence
- Persist beyond individual sessions
- Benefit future hires
- Contribute back to the Ruby ecosystem
Advertise on RubyStackNews
RubyStackNews is a niche publication read by Ruby and Rails developers worldwide. Our audience includes senior engineers, tech leads, and decision-makers from the US, Europe, and Asia.
Sponsorship Options
Your brand featured inside a technical article (clearly marked as sponsored).
Highlighted sponsor section embedded within an article.
Logo + link displayed site-wide in the sidebar.
- Highly targeted Ruby / Rails audience
- Organic traffic from search and developer communities
- No ad networks — direct sponsorships only
Interested in sponsoring RubyStackNews?
Contact via WhatsAppThe Solution: Learning Through Problems and Tests
Instead of focusing on passive reading, the team designed a practice-driven learning model.
Structured by Skill Level
Participants were grouped into levels:
- Beginners – summarizing chapters and explaining concepts
- Intermediate developers – reviewing explanations and solutions
- Advanced developers – designing challenging metaprogramming problems
This structure ensured that everyone learned, regardless of experience.
Learning Through Failing (and Fixing) Tests
Each chapter was paired with practical exercises, validated through automated tests:
- Problems had no single correct solution
- Developers could compare different approaches
- GitHub Actions were used to keep tests green
- CI badges became a shared goal
Instead of memorizing APIs, participants were forced to understand:
- Ruby’s object model
- Inheritance from core classes
- method_missing and respond_to?
- define_method and singleton methods
- How Ruby really executes code
This shifted learning from theoretical understanding to muscle memory.
From Internal Tool to Open Source Resource
What started as an internal experiment evolved into a public GitHub repository:
- A curated set of metaprogramming challenges
- Gradually refined through real-world usage
- Improved via pull requests and community feedback
By making the problems public, the team achieved something important:
The learning material became stronger precisely because it was exposed to others.
External eyes found typos, edge cases, and clever alternative solutions — all of which improved the quality of the exercises.
Scaling Further: Ruby in the Browser with ruby.wasm
Despite its success, one problem remained: accessibility.
To solve this, the project embraced ruby.wasm, allowing developers to:
- Write Ruby code directly in the browser
- Execute tests instantly
- See output and failures in real time
- Switch between Japanese and English
No local setup. No Ruby installation. Just problem-solving.
This significantly lowered the barrier to entry and opened the door to a global audience.
The Role of AI in the Process
The wasm-based platform was partially built using AI agents (notably Claude Code).
AI helped with:
- Refactoring complex problems into browser-friendly units
- Reorganizing test structures
- Translating the platform into English
However, the talk is refreshingly honest about AI’s limitations:
- AI struggles with implicit problem boundaries
- Human guidance remains essential for complex logic
- AI accelerates work — it does not replace expertise
Impact Beyond Learning
The results went beyond education:
- Developers reported stronger confidence with Ruby internals
- The company gained technical visibility
- The project supported recruitment efforts
- The Ruby community gained a reusable learning resource
Most importantly, knowledge stopped being ephemeral.
Key Takeaway
The central message of the presentation is simple but powerful:
Writing problems teaches more than reading solutions.
By forcing developers to struggle productively, knowledge becomes durable, transferable, and shareable.
Final Invitation
The talk closes with an open call to the community:
Create problems. Publish them. Teach by building challenges.
That, more than any book alone, is how mastery is achieved.
Now open for 2026 sponsorships 