DEV Community: George Kosmopoulos

Check the code health of your rails app

George Kosmopoulos — Tue, 17 Jun 2025 14:55:00 +0000

Rails Code Health: Turn Technical Debt Into Hard Numbers

What if your "quick fix" could predict next quarter's delivery delays? What if messy code came with a price tag? What if your codebase could literally tell you it needs therapy?

Meet Rails Code Health - the first gem to put a scientific health score on your Rails codebase, because apparently we needed peer-reviewed research to confirm that spaghetti code is, in fact, terrible.

The $85 Billion "I Told You So" Moment

Here's what researchers found when they studied real production codebases (shocking absolutely no one who's ever worked with legacy code):

💥 Low quality code has 15x more bugs (surprised Pikachu face)
⏰ Takes 124% longer to ship features (somewhere, a PM cries)
🎲 Creates 9x more unpredictable delivery times (your estimates were doomed from the start)

The kicker? 42% of developer time is wasted on technical debt, costing the industry $85 billion annually. That's enough money to buy Twitter... wait, scratch that, bad example. That's enough money to buy a lot of coffee for very tired developers.

Yet only 10% of companies actively manage it. The other 90% are too busy putting out fires they accidentally started.

The Research That Changes Everything (Finally!)

The peer-reviewed paper "Code Red: The Business Impact of Code Quality" analyzed 30,737 files across diverse industries. Scientists literally counted bugs so you don't have to argue with your PM about why that "simple" feature took three sprints.

Translation: That controller you've been avoiding since 2019 isn't just scary—it's statistically proven to be a productivity vampire. 🧛‍♂️

Rails Code Health: Because Your Code Deserves Better Than "It Works™"

This gem transforms academic research into actionable insights for Rails applications. Think of it as a fitness tracker for your codebase, except instead of counting steps, it counts tears shed during debugging sessions.

🎯 Smart Analysis Beyond "It Has Too Many Lines"

# This looks fine to humans who haven't lost all hope...
class UsersController < ApplicationController
  def create
    # 50 lines of business logic, validations, email sending,
    # PDF generation, coffee brewing, existential dread...
  end
end

# But Rails Code Health knows this is a war crime
# Score: 4.2/10.0 - "This method needs an intervention"

📊 One Number to Rule Them All

Health Score: 1-10 scale (like rating your pain at the doctor, but for code)

🟢 8.0-10.0: "Chef's kiss" - Ship fast, sleep well, maybe even have a social life
🟡 4.0-7.9: Manageable technical debt (like a small kitchen fire)
🔴 1.0-3.9: Your code is screaming internally (and so are you)
⚫ <1.0: Abandon all hope, ye who enter here

🔍 Rails-Specific Intelligence (It Speaks Rails!)

Controllers: Counts actions like a bouncer counts troublemakers
Models: Detects fat models before they need bariatric surgery
Views: Spots business logic hiding in templates like a very boring game of hide-and-seek
Migrations: Judges your schema changes harder than Gordon Ramsay judges amateur chefs

See Your Code's Therapy Session

$ rails-health

Rails Code Health Report
========================
🏥 Code Triage Results

📊 Overall Health: 6.8/10.0 (Could be worse! Could be WordPress!)
🟢 Healthy: 89 files (Living their best life)
🔴 Alert: 6 files (Currently having existential crisis)

🚨 Patients Needing Immediate Care:
1. 🔴 app/models/user.rb (2.8/10.0) - *Terminal case*
   • 847 lines - This isn't a model, it's a novella
   • 12 callbacks - More callbacks than a reality TV show

2. 🔴 app/controllers/admin_controller.rb (3.1/10.0) - *Critically obese*
   • 18 actions - REST in peace, RESTful conventions
   • No strong parameters - Security? We don't know her

💰 Business Impact (AKA "Why You Should Care"):
   Fixing alert files could speed development by 55%
   (That's like getting a whole extra developer, but cheaper and less pizza required)

The ROI Calculator (Or: How to Justify Your Refactoring to The Suits)

Based on actual science (not just developer complaints), improving health from 4.0 → 8.0:

For a 10-person team:

55% faster feature delivery = $550k saved annually (enough for a really nice coffee machine)
93% fewer production bugs = Fewer 3 AM phone calls
89% more predictable timelines = Your estimates might actually be... accurate? gasps

Drop-In Integration (Easier Than Your Ex)

# Install (like npm install, but for grown-ups)
gem install rails_code_health

# Analyze (brace yourself)
rails-health

# CI Integration (because humans can't be trusted)
rails-health --format json --output report.json
# Fail build if health drops below 6.0 (harsh but fair)

GitHub Actions Example:

- name: Code Health Reality Check
  run: |
    rails-health --format json | \
    ruby -e "exit 1 if JSON.parse(STDIN.read)['average_score'] < 6.0"
    echo "Your code has been judged... and found wanting"

Beyond Just Metrics (It's Got Personality!)

This isn't another linter that screams about semicolons like a grammar Nazi. It's a business intelligence tool that:

✅ Predicts delivery delays before your PM has to explain them to stakeholders

✅ Prioritizes refactoring with data instead of "this code gives me anxiety"

✅ Connects code quality to money (finally, a language executives understand!)

✅ Builds quality culture without the usual developer smugness

Real Teams, Real Results (Not Fake Testimonials)

"We identified our 3 biggest bottlenecks in 5 minutes. Our velocity increased 40% after addressing them. Also, I can sleep again." - Senior Rails Developer Who Used To Cry

"Finally, concrete numbers to justify refactoring time to management. No more 'trust me, this code is bad' arguments." - Engineering Manager (Reformed Excel Enthusiast)

"The health score became our team's most watched metric. We have a leaderboard now. It's gotten competitive." - Tech Lead (Slightly Concerning Competitive)

Why This Matters Now (Spoiler: Everything Is On Fire)

Developer shortage + 42% wasted time + infinite technical debt = 🔥🔥🔥

You can't hire your way out of technical debt. Trust us, we've tried. But you can measure it, shame it into submission, and eliminate it with the power of science and mild public embarrassment.

Rails Code Health gives you the ammunition to:

Stop playing technical debt whack-a-mole
Justify refactoring without sounding like a perfectionist
Prevent future disasters before they require therapy
Ship faster without sacrificing your sanity (or your weekend)

Common Developer Reactions

😱 "Oh no, my code has a score?" - Yes, and it's probably lower than you think
🤔 "But my code works fine!" - So does a 1994 Honda Civic, doesn't mean you should drive it to a client meeting
😤 "This is just opinion!" - It's literally peer-reviewed research, Karen
🥺 "Can I improve my score?" - That's... that's the whole point

Get Started Today (Your Future Self Will Thank You)

gem install rails_code_health
cd your_rails_project
rails-health
# Prepare for emotional damage

Join the support group of developers building better Rails applications through measurable code quality and shared trauma.

Open source • Research-backed • Rails-optimized • Therapist-approved*

GitHub Repository

Because your code quality should be as measurable as your therapy bills.

*Not actually approved by therapists, but several have expressed concern

PS: I do go to therapy to talk about my emotions and my life, and it is super beneficial. I have never managed to make my therapist laugh and it is not a goal ( just a side quest ). Do take therapy seriously

Intro to Rsmolagent

George Kosmopoulos — Tue, 11 Mar 2025 07:59:34 +0000

So I Made a Thing: RSmolagent for Ruby Devs Who Just Want Stuff to Work

Hey folks! gkosmo here. I wanted to chat about this little library I put together called RSmolagent. It's basically just me wanting to have the cool AI agent stuff that Python devs have, but in Ruby, and without all the fuss.

Why I Built This Thing

Look, I'm a Ruby dev. I like Ruby. It's elegant, it's fun to write, and it just makes me happy. But lately, all the cool AI agent frameworks are in Python. You've got LangChain (which is awesome but huge), and you've got smolagent (which is nice and simple).

I kept thinking: "Why can't we have something like smolagent but for Ruby?" I didn't want to switch to Python just to build AI agents, and I definitely didn't want to deal with some complex Ruby-Python bridge setup that would break in weird ways.

So I did what any slightly stubborn developer would do - I built my own version.

What's an "Agent" Anyway?

Before I dive in, let's talk about what an "agent" is in this context. It's pretty simple:

You've got an LLM (like GPT-4)
You give it access to some tools (like web search, calculators, APIs)
It figures out which tools to use to complete a task
It uses the results from those tools to give you a final answer

That's it. Nothing magical. The LLM is the brain, the tools are the hands, and RSmolagent is the nervous system connecting them.

How RSmolagent Works

The core idea is dead simple:

# You create an LLM provider
llm = RSmolagent::OpenAIProvider.new(
  model_id: "gpt-4",
  client: your_openai_client
)

# You create some tools
web_search = RSmolagent::Tools::WebSearchTool.new
calculator = MyCalculatorTool.new

# You create an agent with those tools
agent = RSmolagent::Agent.new(
  llm_provider: llm,
  tools: [web_search, calculator]
)

# You run the agent with a task
result = agent.run("What's the population of Tokyo multiplied by 3?")

Behind the scenes, the agent:

Asks the LLM what to do
The LLM says "I should search for Tokyo's population, then multiply it by 3"
The agent executes the web search tool
The agent sends the results back to the LLM
The LLM says "now I need to calculate this"
The agent runs the calculator tool
The LLM gets the final answer

It's a loop, but a pretty straightforward one.

Making Your Own Tools

The real fun comes when you make your own tools. Here's a dead simple example:

class DadJokeTool < RSmolagent::Tool
  def initialize
    super(
      name: "dad_joke",
      description: "Get a random dad joke",
      input_schema: {} # No inputs needed
    )
  end

  def execute(args)
    jokes = [
      "Why don't scientists trust atoms? Because they make up everything!",
      "I told my wife she was drawing her eyebrows too high. She looked surprised.",
      "What do you call a fake noodle? An impasta!"
    ]
    jokes.sample
  end
end

Now your agent can tell dad jokes. Revolutionary, I know.

But seriously, you can build tools that:

Query your database
Call your company's internal APIs
Control IoT devices
Generate images
Whatever else you can code in Ruby

The Code Is Stupidly Simple (By Design)

I intentionally kept the codebase tiny. There are basically four main parts:

Agent - Manages the conversation loop
Tool - Base class for all tools
LLMProvider - Talks to language models
Memory - Keeps track of conversation history

That's it. The entire thing is a few hundred lines of code. You could read the entire library in 15 minutes.

Why so simple? Because I wanted something I could understand entirely, modify easily, and not worry about mysterious bugs in some deep dependency chain.

A Real Example

Let's build something slightly more useful - a research assistant that can search the web and summarize what it finds:

require 'rsmolagent'
require 'ruby/openai'

# Set up OpenAI client
client = OpenAI::Client.new(access_token: ENV["OPENAI_API_KEY"]) 
llm = RSmolagent::OpenAIProvider.new(
  model_id: "gpt-3.5-turbo",
  client: client
)

# Create web search tool
web_search = RSmolagent::Tools::WebSearchTool.new

# Create the agent
agent = RSmolagent::Agent.new(
  llm_provider: llm,
  tools: [web_search],
  max_steps: 5
)

# Ask a research question
puts "What do you want to research?"
question = gets.chomp

puts "Researching... (this might take a bit)"
result = agent.run(question)

puts "\nHere's what I found:\n#{result}"

Just like that, you've got a research assistant. No complex setup, no weird Python dependencies, just plain Ruby.

It's Not Perfect (And That's Okay)

Look, RSmolagent isn't trying to compete with LangChain or even smolagent in terms of features. It's a minimal implementation that:

Works with Ruby
Is easy to understand
Gets the job done

It might not have every bell and whistle, but it's a solid foundation you can build on. And since the code is so simple, extending it is straightforward.

Give It a Try

If you're a Ruby dev curious about AI agents but don't want to learn a whole new language or framework, give RSmolagent a shot. It's open source, it's simple, and it works.

Clone it, hack on it, build something cool with it. And if you improve it, send a PR! This is just the beginning.

Because at the end of the day, programming should be fun. And nothing's more fun than building a little AI assistant that can actually do useful stuff.

Catch you later,
gkosmo