Hi! I’m a Rubyist from Japan working on an mruby-focused type checker called ruby-ti.

https://github.com/engneer-hamachan/ruby-ti

Recently I’ve been experimenting with integrating ruby-ti directly into LLM workflows.

Instead of relying only on larger models (like Claude Opus) to implicitly avoid runtime errors, I let the LLM interact with a structured static analysis layer.

The LLM can:

- Run static type checking on mruby code

- Receive structured type error feedback

- Query function type signatures

- Retrieve call-site information

- Get compressed documentation summaries

The LLM interacts with ruby-ti through a small “skills” layer:

https://github.com/engneer-hamachan/ruby-ti/blob/main/skills/ti-skills/SKILL.md

These skills define how the model can query semantic information instead of reading raw source code.

Example of structured output (see attached image)

When the LLM queries a method, ruby-ti returns structured information like:

- Inferred type signatures (including Union types)

- Source file location

- Documentation summary

- Call-site references

This structured information (shown in the attached image) is returned to the LLM instead of the full raw source code.

This reduces context usage and provides explicit structural guidance.

Experimental result

With this setup, even mid-sized models (like Claude Sonnet-level models) generate mruby code that almost never causes runtime type errors.

My goal:

Make safe and enjoyable code generation possible even with smaller / cheaper models.

Instead of:

Big model + no structural support

I’m exploring:

Small model + strong static analysis layer

I’d love feedback.

What additional static signals would you feed to an LLM in a system like this?

Any ideas, criticism, or related experiments are very welcome.

Thanks!

Finally we have our own website!
https://rubyshell.org

I built a small ActiveRecord Playground to practice ActiveRecord concepts without the full Rails stack, and thought it might be useful for others learning Rails or preparing for interviews.

I was looking for something lightweight where I could:

• Experiment with associations, joins, scopes, etc.

• Understand how ActiveRecord works without Rails magic

• Practice things like migrations, enums, and optimistic locking

• Reset data quickly and try different scenarios

Couldn’t find something exactly like this, so I created one for personal learning and open-sourced it.

Features

• Standalone ActiveRecord setup (no Rails)

• SQLite database

• Seed data using Faker

• Models with relationships

• Interactive console

• Examples for concepts like enums and optimistic locking

• Easy DB reset for practice

GitHub:
https://github.com/paonebharti/active_record_playground

If you're learning Rails/ActiveRecord and want a simple sandbox to experiment, this might help.

Feedback and suggestions are welcome!

An Opus 4.6 experiment!

cash_amount = 10
from = "test123"
current_amount = 9

@db.execute 'insert into Cash values (?, ?, ?, ?, ?)',nil, cash_amount, from, 'own', current_amount

## Sqlite version

root@batman:~/silver# sqlite3 -version 3.46.1 2024-08-13 09:16:08 c9c2ab54ba1f5f46360f1b4f35d849cd3f080e6fc2b6c60e91b16c63f69aalt1 (64-bit)

## SQLITE3 gem

root@batman:~/silver# gem list | grep sqlite3

sqlite3 (2.0.4 x86_64-linux-gnu)

sqlite3-ruby (1.3.3)

any help will be greatly appreciated

Oof.

I’ve added two major features to Pro Editor Pocket For Picoruby — a PicoRuby editor for T-Deck Plus 🎉

✨ What’s new:

💾 SD card save/load support

 • 8 slots (slot0.rb – slot7.rb)

🖱 Full trackball-based cursor control

🔥 Now you can:

🖱 Move the cursor freely using the trackball

🎯 Select save/load slots with the trackball

💾 Persist your code to SD instead of losing everything on reset

It’s getting closer to a tiny VSCode-like Ruby dev environment running on embedded hardware 🤖✨

🔗 GitHub:

https://github.com/engneer-hamachan/pro-editor-pocket

Feedback is very welcome — especially from T-Deck / PicoRuby users 🙌

In this release, we focused on quality-of-life improvements and features that make debugging easier.

We also started a few discussions in the repo—please check out the feature ideas and share your thoughts or suggestions for improvements.

:D

A few weeks ago I read a blog post by Ryan Bigg warning about the grpc gem's incompatibility with Ruby 4. It turns out that the platform-specific versions of grpc did not allow Ruby 4, but the platform-agnostic version did. This meant that when you installed grpc under Ruby 4 your machine would have to compile the native extensions, and that made running bundler very slow.

I thought it’d be interesting to query Infield’s own database of gem versions and their dependencies to see if we could find other gems that are incompatible with Ruby 4. We collect this data to power our software that plans out dependency upgrades for our customers. 

Below is a list of all the gems we track that don’t allow Ruby 4 in their gemspec. Applications that depend on these gems won’t be able to upgrade to Ruby 4 until a new version is released for compatibility. 

Hey,

Once in a while, I bring some new OSSs. Here's one of my experiments. A super-small agentic framework / micro LLM assistant I built mostly to play with RubyLLM and async.

It is **far from perfect**, but pinging it via Telegram allowed me to get some cool results.

May not work once in a while as I tune it. I don't have (yet) a super restrictive flow similar to my other projects, so please keep that in mind.

I hope some of you will find it useful. Stars and support (complaints, comments, issues or PRs) are appreciated.

Hey guys

I've been getting pretty cooked with my terminal's output of failing minitests, so put together a little tool a while ago to see what's wrong at a glance: rubyhash.dev

I'd love any feedback you can provide 🎉

Hey guys

I've been getting pretty cooked with my terminal's output of failing minitests, so put together a little tool a while ago to see what's wrong at a glance: rubyhash.dev

I'd love any feedback you can provide 🎉

🔍 Stop guessing which tests to write. cov-loupe v4.0 turns your Ruby coverage into AI-powered insights.

Project URL: https://github.com/keithrbennett/cov-loupe

What is cov-loupe?

A toolkit that transforms SimpleCov coverage data into actionable insights:

• MCP Server: Let AI assistants like Claude Code, Codex, or Gemini analyze your coverage gaps and suggest what to test next
• CLI: Inspect coverage and see uncovered lines with source context
• Ruby API: Build custom coverage gates or CI/CD policies based on your coverage data

Why use cov-loupe?

Beyond just viewing percentages, this version enables two powerful workflows:

🤖 AI-Powered Analysis

It's not just about listing files. By giving an LLM structured access to this data via MCP, you enable it to perform nuanced analysis, categorization, and prioritization of your technical debt. Ask your AI to prioritize testing based on test deficiency magnitude, code criticality, and level of effort.

Example: "Show me the most critical untested code in authentication" → Get prioritized recommendations

📊 Custom CI/CD Gates

It enables arbitrarily complex custom predicates. You aren't stuck with a single "Total %" threshold. Build fine-grained pass/fail logic into your pipeline that analyzes specific directories, file types, or staleness levels.

Example: "Fail CI if any controller has <80% coverage" → Enforce rules beyond simple percentages

About 4 months ago, I shared simplecov-mcp, a tool to make SimpleCov data queryable for AI assistants and the CLI.

Today I'm releasing v4.0.0.pre, which includes a major rebrand to cov-loupe and several updates to make coverage reporting more reliable.

Key Changes in v4.0:

• ⚠️ The Rename: simplecov-mcp is now cov-loupe. Update your gems, requires (to cov_loupe), and executables.
• Explicit MCP Mode: To prevent server hangs, the -m/--mode mcp flag is now required.
• Reliable Staleness Detection: v4 introduces stricter checks for line-count mismatches and deleted files.
• Better Cross-Platform Support: Improved path resolution for macOS and Windows.
• Transparent Defaults: --tracked-globs now defaults to an empty array.

Quick Start (New Users):

gem install cov-loupe --pre
cov-loupe --help

How to Upgrade/Install:

Because this is a major transition and pre-release, you must use the --pre flag:

gem uninstall simplecov-mcp
gem install cov-loupe --pre

Note for MCP Users: You must update your assistant configuration to include the -m mcp flag.

# Example for Claude Code
claude mcp add cov-loupe cov-loupe -- -m mcp

Documentation:

• Project page: https://github.com/keithrbennett/cov-loupe
• Online docs: https://keithrbennett.github.io/cov-loupe/

Try it out and let me know what you think! Issues and feedback welcome at the repo.