The evening kicked off with Chris Fung introducing Binti and their mission. Binti builds a platform for child care agencies with the goal of making sure every child gets a home. Recently, they added AI features to help social workers work more efficiently—so much so that they were even mentioned by Anthropic's CEO in Forbes.

Next, Irina spoke about the upcoming SF Ruby Conference. I'm excited to attend The Ruby Passport will be available there. Tickets currently have a $50 discount,

While talking about the recent Ruby Central changes, I especially liked her quote: "We can choose to believe that every person is actually acting from the best possible intentions." It was a refreshing reminder of the positive spirit in the Ruby community.

The talks then continued:

• André Arko introduced rv.dev, a new Ruby version manager inspired by uv and built in Rust.
• Cade Friedenbach gave a talk on how Binti built their webhooks and data export platform. They kept things simple with Service Objects, Wisper, and background jobs, and used JSON schema validation before saving to the database via activerecord_json_validator.
• Kody Kendall spoke about llamapress, an open-source platform for building Ruby on Rails apps with LLMs. He explained how Rails runner can be used as a tool for agentic coding, and why Rails conventions and concise syntax make it especially suited for AI-driven development.
• Arjun shared how Ruby is being used in medical software to build 3D models from 2D scans. It was exciting to see Ruby applied outside of web development. He also talked about the importance of compliance and testing in the medical field—no "move fast and break things" there.
• Finally, Pranav from Chatwoot presented their open-source gem for building AI agents based on Ruby LLM. This is the foundation behind Captain, their agentic customer support assistant. It enables customers to create their own assistants by providing custom instructions to triage support tickets. I liked how simple their API was. After the talk, I got to chat with him about Chatwoot's journey and how they've kept their architecture and deployment simple.

Overall, it was a fantastic meetup. It was great to see the Ruby community experimenting with AI in practical ways, beyond the hype.

Drew Hoskins introduced Temporal, which now has an official Ruby SDK. He showed how we can build Durable Execution with distributed systems. He demoed a simple workflow using Temporal that pulls a user's location using two external services. I've built workflow engines in the past using background jobs and Redis, but as workflows grow in complexity, they quickly become a pain to manage. Temporal makes it easier to focus on your business logic than spend time managing the infrastructure.

Enrique Mogollan presented his MCP server inspector written in Ruby. He demoed the CLI version and shared his plans for a future web UI.He also pointed us to mcpui.dev, an interesting project that lets you build dynamic UIs for MCP servers.

Miles Georgi introduced Foobara, a new Ruby framework centered around the command pattern. It provides structure to the classic Service Object approach and offers a way to organize apps around clearly defined commands.

Irina Nazarova, CEO of Evil Martians, shared how her team helped Whop reduce CI time by 50%.

Some practical takeaways:

• Skip logging in tests
• Avoid external API calls (use mocks instead)
• Be mindful of what your factories create — reuse associated instances when possible

I also discovered a couple of tools worth trying:

• test-queue, an alternative to parallel_tests
• test-prof, a Ruby test profiling toolkit

Sergey Karayev closed out the talks with a session on programming with AI agents. He shared do's and don'ts when working with LLM coding agents and explained how to draft an effective agent.md.His demo of Superconductor was a fun look at what's possible with modern AI tooling.

Between talks, we had an open mic session where I officially launched my new newsletter: TokenRuby.

That sent me down a rabbit hole reading about the history of feed formats—RSS, Atom, and how we got here. At their core, these formats were designed to make content easy to read and parse for machines.

Wait, it sounds familiar? Yep LLMs.

As AI continues to grow, we'll probably need something similar: a clean, predictable format that LLMs can easily understand. There's already an effort around making llms.txt a standard.

But hey, the modern web isn't just hard for LLMs. Between SPAs, trackers, cookie banners, autoplay videos, permission requests and that one weird floating chat icon that blocks the text—maybe we humans need help too.

Can we have humans.txt please? A sane simple clean readable format for us humans.

I am happy LLMs are pushing us to make web back to old days of simple HTML. Because just like baggy jeans, everything good eventually comes back in style.

Refinements were introduced in Ruby 2.4 as a better alternative to monkey-patching. It allows to override a core class method in a limited scope. On the other hand, monkey patching changes the method across the whole program.

Here's the example I saw:

# frozen_string_literal: true

module Isolator
  module ThreadFetch 
    refine Thread do
      def fetch(key, fallback = :__undef__)
        raise KeyError, "key not found: #{key}" if !key?(key) && fallback == :__undef__

        self[key] || fallback
      end
    end
  end
end

This overrides Thread's fetch method.

Later in the same gem, it's used like this

module Isolator
  using Isolator::ThreadFetch

  class ThreadStateProxy
    # Only within this scope, Thread#fetch behaves as defined above
    ...
  end
end

What's nice here is that Thread#fetch isn't changed globally. The override only applies inside the Isolator::ThreadStateProxy module. Other parts of the app that use Thread won't be affected.

The first talk was from the Figma team discussing their tech stack. They use Sinatra, ActiveRecord, and a custom background job scheduler. They are heavy users of Sorbet. Currently, they are in the process of modularizing their monolith using Packwerk.

They also gave a demo of their internal admin app. It has a unique structure where they define the panel in Ruby, which then compiles to YAML/JSON and is rendered using React.

Marco Roth gave a deep dive into his new project, Herb, which is a language server for .erb files. Excited to see better tooling for .erb files.

👉🏽 Slides

Finally, the talk was from Jeremy Evans. He discussed how he fixed unnecessary object allocations. It definitely piqued my interest in Ruby VM memory management.

👉🏽 Slides

Along with the great talks, there was another highlight for me. I met a friend after almost a decade. We first connected at PuneRB and stayed in touch since then through Twitter and now, here we were, catching up at a Ruby meetup on the other side of the world.

And what a day it was.

We had a strong turnout, with over 55 developers. We kicked off with a quick orientation, outlining the schedule and setting the tone for the day. People started forming teams, throwing around ideas, and diving into code. People brought some great vibes. One participant showed up with a full-fledged multi-monitor setup — yes, you read that right, multiple monitors at a hackathon. Meanwhile, someone else was casually vibe-coding on an iPad.

I knew it was a scam, but for my own entertainment, I decided to call them.

After some back and forth, they asked me to join a remote control session using Zoho Assist. I clicked the link they sent and pretended to follow along.

I kept pretending the page was loading. While keeping them engaged, I decided to report to Zoho about scammers abusing their product.

Zoho has a large “Report Abuse” CTA on the page, so I guess they are aware of this issue.

I filled out the form with the given session ID. It turns out there's a bug in their frontend code that prevents submitting the form.

Frustrated, I opened up inspect element and found the following event handlers:

window.addEventListener("DOMContentLoaded", () => {
    reportOnload();
    document.getElementById("name")?.addEventListener("keyup", () => {
        submitCont(this.form, false, 'name')
    });

    document.getElementById("phone")?.addEventListener("keyup", () => {
        submitCont(this.form, false, 'phone')
    });

    document.getElementById("Email")?.addEventListener("keyup", () => {
        submitCont(this.form, false, 'email')
    });

    document.getElementById("sessionCode")?.addEventListener("keyup", () => {
        submitCont(this.form, false, '')
    });

    document.getElementById("abuse_desc")?.addEventListener("keyup", () => {
        submitCont(this.form, false, 'abuse')
    });

    document.getElementById("report_btn")?.addEventListener("click", () => {
        submitCont(this.form, true, '')
    });
});

They were using arrow functions with an incorrect reference to this. Since arrow functions do not bind their own this, this.form is undefined in these callbacks.

I found the expected payload for the form and submitted the request via curl.

They didn't have any captcha or CSRF token. I emailed their team about the issue.

Who knew a playful call with scammers would lead to a debugging session.

Later, I worked on the event presentation I told myself I wouldn't use AI for it—but I caved and used it to pick the right emojis.

It was satisfying to see months of planning come together. But of course, no matter how early you start, there's always something left to do until the last minute. Damn Parkinson's Law

One thing I liked is their simple but powerful implementation of relationship-based access control (ReRBAC).

It stores tuples of subject, action, and object. If the tuple exists, then the action is allowed. A light version of Google's Zanzibar project.

• authorization.rb
• Authorization

Even though I'm not a coffee drinker, I still ordered the Rose Cardamom Honey ☕️. Highly recommend!!

There were lots of fellow hackers around.

There's something about working from a café—despite the people, the music, and the chatter, I was still able to do deep work (without headphones).

I also submitted my blog to the r/nextjs subreddit today. I was surprised by the responses. I got a lot of positive comments. That's not usually been my experience with Reddit 😅.

One thing I realized while reviewing the post: I'm not optimizing images in my blogs or notes. That note ended up loading 13MB just for a single image 😬.

Lesson learned: don't ship 13MB images to production. Time to switch to next/image before Reddit calls me out.

I managed to listen to a 6-hour podcast:Lex Fridman with DHH.

I made some updates to the blog

• Added a new favicon
• Upgraded NextJS to v15

Even though it's a JS framework, the focus is more on the backend. You can use any frontend library. It has official support for InertiaJS.

I like that it's strongly opinionated and puts focus on developer experience.

I went through the entire documentation. It's hard to explain, but it has taste—something about it just feels well-thought-out and put together with care.

Funny how reading good docs can trick you into redesigning your blog font at midnight. Anyway, Instrument Sans it is.

• Added the favicon image. I kept it simple. It is a letter Y with black background.
• Added other icons for apple-touch and android-chrome
• Added a redirect for www to root. Now https://www.yatishmehta.com redirects to https://yatishmehta.com

After reading it, I started wondering how the OS knows when a Fiber can resume. I dug deeper and learned about epoll_ctl / epoll_wait on Linux, and their macOS equivalent, kqueue and kevent.

With some help from ChatGPT, I wrote a C program that uses kevent to wait for STDIN input asynchronously. It was a good exercise to learn these low level OS primitives

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/event.h>
#include <sys/time.h>
#include <fcntl.h>

int main() {
    int kq = kqueue();
    if (kq == -1) {
        perror("kqueue");
        exit(1);
    }

    struct kevent change;
    EV_SET(&change, STDIN_FILENO, EVFILT_READ, EV_ADD | EV_ENABLE, 0, 0, NULL);

    printf("Waiting for input (kqueue)...\n");

    struct kevent event;
    int nev = kevent(kq, &change, 1, &event, 1, NULL);  // NULL = block forever

    if (nev == -1) {
        perror("kevent");
        exit(1);
    }

    if (event.filter == EVFILT_READ) {
        char buffer[1024];
        ssize_t n = read(STDIN_FILENO, buffer, sizeof(buffer) - 1);
        if (n > 0) {
            buffer[n] = '\0';
            printf("Read from STDIN: %s\n", buffer);
        }
    }

    close(kq);
    return 0;
}

This gave me a better understanding of OS Kernel abstractions.

➡️ View the deploy.yml

While setting this up, I forgot to set one of the environment variables from GitHub secrets in the workflow. I forgot secrets are not available as environment variables automatically

Next up:

• Move the container registry from Docker Hub to GitHub Container Registry.
• Optimize the deploy step (currently takes around 4 minutes).

The design of this notes system is inspired by Andrew Healey's notes.

Getting Started with YARD

You can document your Ruby code using YARD by following a specific syntax. For example:

class Person
  # Greets a person
  #
  # @param [String] name the name of the person
  #
  # @return [String] the greeting
  def greet(name)
    "Hello #{name}"
  end
end

Installation and Usage

Install the YARD gem using:

gem install yard

To generate documentation, run:

yard doc person.rb

This generates a documentation site in the doc directory. You can preview it locally using:

yard server

Since the documentation consists of static HTML files, you can host it on any web server.

YARD Cheatsheet

# Represents a generic document in a document management system.
# @abstract
# @author John Doe
# @since 1.0.0
# @deprecated Use NewDocument instead.
class Document
  # @!attribute [r] title
  #   @return [String]
  attr_reader :title

  # @!attribute [w] description
  #   @return [String]
  attr_writer :description

  # @!attribute [rw] sections
  #   @api private
  #   @return [Array<Section>]
  attr_accessor :sections

  # Initializes a new Document instance.
  # @note This method should be called with care.
  #
  # @param [String] title the title of the document
  # @param [String] description the description of the document
  # @param [Hash] options additional configuration options
  # @option options [Boolean] :editable whether the document can be edited
  # @yieldparam [String] content The content of the document.
  # @yieldreturn [String] Returns a modified content.
  #
  # @raise [ArgumentError] if the title is nil
  #
  # @return [Document] a new Document instance
  def initialize(title, description, options = {})
    raise ArgumentError, "Title cannot be nil" unless title

    @title = title
    @description = description
    @editable = options.fetch(:editable, true)

    @content = yield(content) if block_given?
  end

  # Edits the document content.
  #
  # @overload edit(new_content)
  #   @param [String] new_content the new content for the document
  #   @return [Boolean] true if editing was successful, false otherwise
  #
  # @overload edit
  #   @yield Gives a block to process the current content.
  #   @yieldreturn [String] Returns the new content after processing.
  #   @return [Boolean] true if editing was successful, false otherwise
  #
  # @deprecated Use `modify` method instead.
  def edit(new_content = nil)
    if new_content
      @content = new_content
      true
    elsif block_given?
      @content = yield(@content)
      true
    else
      false
    end
  end

  # @todo Implement a proper save mechanism
  def save
    # Implementation pending
  end

  # Views the document
  #
  # @example Viewing the document title
  #   document.view_title #=> "Sample Document"
  #
  # @see #edit
  # @return [String] the title of the document
  def view_title
    @title
  end
end

I created a cheatsheet of all YARD tags: It is available as a gist.

Custom Tags in YARD

YARD supports .yardopts for custom configuration, including custom tags. I use this to document Rails controller actions:

--tag url
--tag action

Example usage in a Rails controller:

class DocumentsController < ApplicationController

  # @url /documents
  # @action GET
  #
  # List all documents.
  #
  def index
    @documents = Document.all
  end

  # @url /documents/:id
  # @action GET
  #
  # Show a single document.
  #
  def show
    @document = Document.find(params[:id])
  end
end

Since params is not explicitly passed as an argument, you cannot use @param and @option to document them. One of the methods that the YARD author suggests to document these methods is to use the @overload tag.

# @overload show(params)
#   @param params [Hash]
#   @option params [String] :id the id of the document
def show
  @document = Document.find(params[:id])
end

YARD in VSCode

VSCode has a YARD extension that provides auto-completion for YARD tags. You can generate documentation for a method by placing the cursor at the end of its definition and pressing Ctrl+Alt+Enter (or Option+Command+Enter on macOS).

For example, with the cursor anywhere on this line:

def foo(name, baz = false) # <- put cursor at any place of this line
end

The extension generates:

#
# <Description>
#
# @param [<Type>] name <description>
# @param [<Type>] baz <description>
#
# @return [<Type>] <description>
#
def foo(name, baz = false)
end

Conclusion

YARD is a powerful tool for documenting Ruby code. It improves code readability if used correctly.

Happy documenting!

Include

It adds methods as instance methods

module Swimmable
  def swim
    "I can swim!"
  end
end

class Fish
  include Swimmable
end

fish = Fish.new
puts fish.swim # => "I can swim!"
puts Fish.ancestors # => [Fish, Swimmable, Object, Kernel, BasicObject]

Extend

It adds methods as class methods

module Flyable
  def fly
    "I can fly!"
  end
end

class Bird
  extend Flyable
end

puts Bird.fly # => "I can fly!"
puts Bird.ancestors # => [Bird, Object, Kernel, BasicObject]

Prepend

It adds methods as instance methods but with higher precedence.

module Logger
  def log_action
    "Logged: #{super}"
  end
end

class Action
  prepend Logger

  def log_action
    "Some action"
  end
end

action = Action.new
puts action.log_action # => "Logged: Some action"
puts Action.ancestors # => [Logger, Action, Object, Kernel, BasicObject]

Normally, prepend is defined at the end of the class definition.

You can also prepend a module outside the class definition

Action.prepend(Logger)

Consecutive prepends

module Formatter
  def display
    "Formatted: #{super}"
  end
end

module Validator
  def display
    "Validated: #{super}"
  end
end

class Report
  prepend Formatter
  prepend Validator

  def display
    "Report content"
  end
end

report = Report.new
puts report.display # => "Validated: Formatted: Report content"
puts Report.ancestors # => [Validator, Formatter, Report, Object, Kernel, BasicObject]

When there are multiple prepends, the first lookup is from the last prepend.

Hence the lookup flow would be as follows. prepend(n) -> prepend(n-1) -> class -> include(n) -> include(n-1)

Prepend is used to insert a module's methods at the beginning of a class's method lookup chain, before the class's own methods. This means that when a method is called, Ruby will first look for it in the prepended module before looking in the class itself.

I've used variations of these snippets in real projects.

Ruby

It is a single-file Rails application used for testing ActiveRecord methods. It's based on the official Rails issue template, but I've modified it to use PostgreSQL as the database. There are also templates available to test other parts of a Rails application.

# frozen_string_literal: true

require "bundler/inline"

gemfile(true) do
  source "https://rubygems.org"

  gem "rails"
  gem "pg"
end

require "active_record"
require "logger"

ActiveRecord::Base.establish_connection(
  adapter: "postgresql",
  database: "postgres",
  host: "localhost",
  username: "postgres",
  password: "",
  port: 5432
)

ActiveRecord::Base.connection.drop_database("rails_blog_demo") rescue nil
ActiveRecord::Base.connection.create_database("rails_blog_demo")
ActiveRecord::Base.establish_connection(
  adapter: "postgresql",
  database: "rails_blog_demo",
  host: "localhost",
  username: "postgres",
  password: "",
  port: 5432
)

ActiveRecord::Base.logger = Logger.new(STDOUT)

ActiveRecord::Schema.define do
  create_table :posts, force: true do |t|
    t.string :title
    t.text :content
    t.timestamps
  end

  create_table :comments, force: true do |t|
    t.belongs_to :post, null: false
    t.text :body
    t.timestamps
  end
end

class Post < ActiveRecord::Base
  has_many :comments, dependent: :destroy
end

class Comment < ActiveRecord::Base
  belongs_to :post
end

post = Post.create!(title: "Sample Post", content: "This is a sample blog post.")
comment = post.comments.create!(body: "Great post!")

puts "Post: #{post.title}"
puts "Comment: #{comment.body}"
puts "Post has #{post.comments.count} comments"

CSS

CSS that makes a circle with a colorful gradient that spins, changes color, and animates.

.circle {
  width: 150px;
  height: 150px;
  border-radius: 50%;
  background: linear-gradient(45deg, #60a5fa, #a855f7);
  margin: 20px auto;
  animation: 
      rotate 4s linear infinite,
      colorShift 6s ease-in-out infinite,
      bounce 3s ease-in-out infinite;
}

@keyframes rotate {
  from { transform: rotate(0deg); }
  to { transform: rotate(360deg); }
}

@keyframes colorShift {
  0% { filter: hue-rotate(0deg) brightness(1); }
  25% { filter: hue-rotate(90deg) brightness(1.2); }
  50% { filter: hue-rotate(180deg) brightness(0.9); }
  75% { filter: hue-rotate(270deg) brightness(1.1); }
  100% { filter: hue-rotate(360deg) brightness(1); }
}

@keyframes bounce {
  0%, 100% { transform: scale(1); }
  50% { transform: scale(1.05); }
}

package main

import (
	"fmt"
	"log"
	"net"
)

func main() {
	ipv4Addr, ipv4Net, err := net.ParseCIDR("192.0.2.1/24")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(ipv4Addr)
	fmt.Println(ipv4Net)

	ipv6Addr, ipv6Net, err := net.ParseCIDR("2001:db8:a0b:12f0::1/32")
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(ipv6Addr)
	fmt.Println(ipv6Net)
}

// RockPaperScissors.tsx
import React, { useState } from 'react';

const choices = ['Rock', 'Paper', 'Scissors'] as const;
type Choice = typeof choices[number];

const getWinner = (player: Choice, cpu: Choice) => {
  if (player === cpu) return "It's a tie!";
  if (
    (player === 'Rock' && cpu === 'Scissors') ||
    (player === 'Paper' && cpu === 'Rock') ||
    (player === 'Scissors' && cpu === 'Paper')
  ) return 'You win!';
  return 'You lose!';
};

export default function RockPaperScissors() {
  const [player, setPlayer] = useState<Choice | null>(null);
  const [cpu, setCpu] = useState<Choice | null>(null);
  const [result, setResult] = useState('');

  const play = (choice: Choice) => {
    const cpuChoice = choices[Math.floor(Math.random() * 3)];
    setPlayer(choice);
    setCpu(cpuChoice);
    setResult(getWinner(choice, cpuChoice));
  };

  return (
    <div style={{ textAlign: 'center', fontFamily: 'sans-serif' }}>
      <h1>Rock Paper Scissors</h1>
      {choices.map(c => (
        <button key={c} onClick={() => play(c)} style={{ margin: '0 10px' }}>
          {c}
        </button>
      ))}
      {player && cpu && (
        <div>
          <p>You chose: {player}</p>
          <p>Computer chose: {cpu}</p>
          <h2>{result}</h2>
        </div>
      )}
    </div>
  );
}

CREATE TABLE users (id SERIAL PRIMARY KEY,
                              name TEXT, manager_id INT REFERENCES users(id));

WITH RECURSIVE management_chain AS
  (SELECT id,
          name,
          manager_id,
          1 AS LEVEL
   FROM users
   WHERE id = 7
   UNION ALL SELECT u.id,
                    u.name,
                    u.manager_id,
                    mc.level + 1
   FROM users u
   JOIN management_chain mc ON u.id = mc.manager_id)
SELECT *
FROM management_chain
ORDER BY LEVEL;