- RoboRuby
- Posts
- Ruby AI News - October 14th, 2026
Ruby AI News - October 14th, 2026
Generate but verify
Matt Solt
October 14, 2026
Welcome to the 39th edition of Ruby AI News! This edition features a continued look at the future of Rails, RubyLLM 2.1, decision models, impatient programming, and much more.
Top Stories
The Future of Rails Continued
Day Two
The last edition ended on this era being a new day for Rails, and the community has been building on that ever since.
Andy Croll read the keynote as the underpants gnomes plan. Step one, models got good at writing code. Step three, models write all the code. Step two is left blank, and Andy argues step two is where the real work is and what Rails opinions were meant for.
Ernesto Tagwerker, who has spent more than 60,000 hours at FastRuby.io upgrading other people's Rails apps, came to the same conclusion from the maintenance side. Treating code as a black box is a big bet for any team without 37signals' resources, and he would "much rather that someone be reading Ruby."
He also asked the question a lot of people were thinking. If David were to pass the baton, who would pick it up? His answer is that Rails may need two leaders, one for beginners and one for advanced users.
Roberto Nogueira took the opposite reading and still settled on Ruby. If AI becomes the layer closest to human intent, the language becomes an implementation target, and Ruby's job becomes being the most readable thing a person reviews. "Readability may become more valuable than writability." Pencils down, in his words, "does not mean Ruby down."
No Adult Supervision
Julik Tarkhanov captured the mood well. The old order losing interest "frees up the room," and the Weimar comparison is about what gets made when nobody is in charge.
The evidence is in the RubyGems index. About 4,600 new gem names were registered in the year to October 2025 and about 8,900 in the year since, and the jump starts in March. "It is not a slope, it is a step."
PDF generation in Ruby went from a wasteland to two good options. Julik's Parquet library took him a few days, where zip_kit took months. Whole problem areas that used to be "too much" for Ruby are getting fixed by people who stopped waiting for permission.
Many Keepers
Sam Ruby took the 4GL thesis to Pune and opened day two of Deccan Queen on Rails. Many Keepers is the companion post, and stated the thesis as "A framework is a language without a compiler." Fourth-generation languages died because their compilers were expensive. SQL survived because it had many vendors keeping it alive. Agents made the compiler cheap, so the open question is who will maintain it.
One of the people already maintaining it is Tobi Lütke. Besides getting roundhouse check through Shopify core, he hand-ported Campfire to plain Ruby 4, no Rails, byte-identical HTML, 15 to 27 times faster. Then he asked for the thing a hand port can't give you, Rails performance "transpiled deterministically to Ruby with the magic removed."
Sam's Keep the Gems explains why that path matters for any large app. Of Mastodon's 113 runtime gems, 90 have no Rails dependency at all. Transpile to Ruby and you keep the ecosystem. You are not going to vibe code a replacement for it.
Performance is improving too. What a JIT Can't Know ran Shopify's Lobsters benchmark and found Roundhouse more than four times faster than Rails with YJIT or ZJIT turned on. A JIT makes each instruction cheaper, and a compiler that reads the whole app removes the work Rails repeats on every request, deciding what has_many means. "The two multiply." Active Record time on that benchmark dropped from 400 milliseconds to 32.
Two days later Whole Routes in a Box used Ruby 4's experimental Ruby::Box to run the compiled code inside a normal Rails process. A route moves to the box only when the analysis can vouch for all of it, and everything else stays on Rails. On Lobsters, 48 of 84 GET actions qualify and run 2.3 to 4.7 times faster. That is the incremental path a real team needs, keep your app, keep your gems, and let the compiler take over one proven route at a time.
What Checks the Checker
In The Browser Half, both the compiled Campfire and the hand-written Rust port shipped the same broken ping suggestions, and the port's parity harness passed all 5,018 of its cells anyway. Campfire's JavaScript is larger than its models and controllers combined, and nothing checks the strings that wire Ruby, ERB, and Stimulus together.
Generated Rails pointed Roundhouse at apps written by agents through Paweł Strzałkowski's Hifumi, which generates Rails 8 apps from a prompt. Those apps sit close to the defaults, which makes them good test material, and Rails' own authentication generator exposed gaps Campfire never did, including a filter the compiler silently dropped.
Sam's proposal is to run roundhouse check inside Hifumi's verify loop and offer a compiled Dockerfile at export, which is most of the beginner pipeline from last edition in one tool. Resolvers Have Types Too extended the same checking to GraphQL, following each field down to the Ruby that has to return it.
Every one of these posts asks the same question as the last edition. Where did the information come from, and what checked the result? For code, the answers are getting sharper every week. For the rest of what agents do, the decisions, the summaries, the judgment calls, and as we can see from the other top stories, the checking is just getting started.
Measure & Judge with RubyLLM
Carmine Paolino shipped two major versions of RubyLLM in four days, and the second one went out on stage at Deccan Queen on Rails, the same conference where Sam Ruby made the case for Rails as a language with a compiler. Roundhouse asks what checks the code. RubyLLM 2.1 asks what checks the model.
The Biggest Release Since 1.0
RubyLLM 2.0 officially launched October 5th, and Carmine called it "the biggest release since 1.0." The headline is tool approval that survives your infrastructure. Mark a tool with requires_approval and the loop stops before it runs, with the pending call stored in the database, so "the approval can come tomorrow, from another process, after two deploys." The agent loop is broken into verbs you can call one at a time, and there's "no workflow engine and no state machine to serialize."
The release also added video, speech, OCR, reranking, normalized citations from any provider, and a usage ledger that records cost per attempt, failures included, with an unknown price stored as nil instead of zero. And the gem now ships its own skill for coding agents, the knowledge traveling with the code exactly the way the last edition hoped gems would.
Spencer Miskoviak at Tern walked through a travel agent with more than 100 tools, where every v1 workaround for approvals, caching, error routing, and the tool loop now has a first class API. Tern moved 120,000 chats and 2.5 million messages into the gem's new tables, and the four stage migration they built to do it without downtime went back upstream into the gem.
Islam Gagiev at JetRockets wrote another migration story. They deleted ruby-openai, a hand-written tool loop, two monkey patches, a client facade, and a prompt store, and admit a lot of it already existed in RubyLLM 1.x and they never adopted it.
Judgments
RubyLLM 2.1 followed on October 8th, and its most important feature is a new kind of question. A judge declares typed questions about your own data, a probability, a choice, or a score, and asks them all over the same input in one request.
What comes back are "probabilities a model measured, instead of a confidence number it wrote as text." Ask a chat model how sure it is and it will write a number, and the number is just more generated text. A judgment gives your code a probability it can put a threshold on, so the decision about what happens at 0.6 versus 0.96 stays in your code, where you can test it.
The other half is evaluations. You subclass RubyLLM::Evaluation, keep the cases in a YAML file beside it, and run bin/rails "ruby_llm:eval[DocsEvaluation]", which exits non-zero when it fails. That means an AI feature can sit in bin/ci next to RuboCop, Brakeman, and roundhouse check, and the test suite decides whether it ships, the same rule the last edition proposed for code. An evaluation can use a judge as its grader, which closes the loop.
2.1 also brings an MCP client where "an MCP server is a Ruby class you own," with per-user OAuth, an allowlist of tools, and approval on the dangerous ones. OpenTelemetry tracing records models, tokens, and tool names but never prompts or responses. And "2.1 does less work on every call, with no code changes."
Carmine's own summary is that RubyLLM is now "missing nothing" from LangChain, LangGraph, and LangSmith.
Around the Edges
Andrey Samsonov, a RubyLLM contributor, released ruby_llm-modes, which lets a cheap classifier pick a named configuration for each turn of a chat, its instructions, tools, model, and thinking effort, while the history stays shared. His router falls back to a default when confidence drops below a threshold you set, and it uses a judge to decide.
Dewayne VanHoozer built two providers on the 2.0 release candidates. ruby_llm-providers-lms connects RubyLLM to LM Studio across all of its API styles, with 15 example apps and a README that is explicit about which models misbehave on which protocol. ruby_llm-providers-apfel reaches Apple's on-device foundation model through the apfel server, entirely offline.
Jeveverything is Awesome
RubyLLM judges default to a brand new built-in provider, Jev from TypeSafe, and the models behind them are not chat models at all.
Choices, Not Sentences
The timeline in the last edition ended with Jev, and I wrote that calibrated decision models might help verify the work that isn't code. A month later, Rubyists have published at least ten libraries for it, TypeSafe still hasn't released a Ruby SDK, and Jev already has competition.
What Jev Is, and Isn’t
Juan Vasquez at OmbuLabs wrote a clear explainer. TypeSafe announced Jev on September 15th as the first "System One" model. You send it a state, the messy text you want judged, along with typed questions. A Noul asks how likely a statement is to be true, a Choice picks one of your options, and a Score places the input on a rubric you wrote. Every answer comes back as a probability, and the model can't answer outside your options.
Calibrated means an answer given at 0.8 should be right about 80 percent of the time across many calls. It doesn't mean any single answer is right, and TypeSafe's own docs list where Jev struggles, including counting, dates read as text, overly literal readings, and prompt injection. It costs $0.042 per million input tokens, output is free, and a query takes about a tenth of a second.
The model makes a narrow call, and your Ruby decides what to do with it, with a threshold you can test. It is also exactly what a RubyLLM judge returns.
The Ruby Response
Carl Dawson's hunch turns a decision into plain English control flow, Hunch.almost_certainly?("fraudulent", given: order), and works with any server that speaks the System One API.
Maxim Veysgeym's jev-feels goes further, with meanings defined once and attached to model fields, so email.feels?(:urgent) reads like any other predicate, plus Rails validations, pattern matching, and record and replay for tests.
Daniel Badde's typesafe-ai-rails stores confidence rules in the database and fails closed, refusing to run a side effect unless a rule exists for it.
Andrii Furmanets ported the official JavaScript SDK because "there was no Ruby SDK yet," and Vincent Rolea claimed the jev gem name with a small, clean client.
This r/rails thread for jevalyn, another wrapper, produced a useful feature request, a confidence threshold per question instead of per class, and Ray Hughes shipped it.
Igor Kasyanchuk built one of the first real apps on it with voice_control, a Rails engine where you speak a command, and Jev picks from the commands you defined in Ruby plus every link and button on the current page. His demo edits a user, sets a balance, undoes it, and upgrades a plan without touching the mouse.
New Patterns
Kieran Klaassen found another use case. He asks Jev named questions about each document and uses the answers as the embedding. An email that says "I got charged twice this month" becomes is a customer 1.0, urgent 0.9, about billing 1.0, needs a reply 1.0, and plain cosine search does the rest. Adding a dimension means adding a question, and when a search result looks wrong, you can read why.
Inside agent loops, the idea is to hand the forks to a decision model and keep the generation for the frontier model. X/Twitter user Avid described a harness where Jev picks which notes to load, which worker gets a task, and which recovery path to take when a tool fails, choosing only from options the harness prepared and validated.
Jev Has Company
Cloudflare released Clef and Clef-flash as open-weight decision models under Apache 2.0, "fully Jev-API compatible," with image input and a larger context.
Valentino Stoll ported the open-weight Laya model to Ruby as ruby-laya, which runs on your CPU for nothing in about 33 milliseconds by his measure. His README benchmarks it against Jev. Laya wins on news classification and loses badly on banking intents and multilingual text.
Kieran Klaassen added OpenAI's own decision model to RubyLLM 2.1, and Perplexity now has one too.
Adam Hevenor ran an independent comparison. On reranking search results, "Perplexity edges Jev," Clef-flash only held up when asked about one document at a time, and most of the gaps fell inside the confidence intervals. He advises using Jev when you need independent scores you can threshold, and something cheaper when you only need an order.
The API shape is already converging, a state and typed questions, and a choice your code makes on a probability. If decision models are going to be a category and not a vendor, Ruby needs one client that speaks to all of them, and Obie Fernandez has been building it.
Impatient Programming
Obie Fernandez released ruby_decision_model 0.2 on October 7th, a single Ruby client to talk to Jev, OpenAI's decision model, Cloudflare's Clef, Perplexity's decider, Databricks, and any self-hosted server that speaks the System One API. It requires nothing beyond the standard library, and switching vendors means changing the provider.
He showed why that matters with one support ticket, a checkout returning 500 for every customer, asked the same four questions on five models. Is it an outage, is it urgent, which team owns it, and how severe is it? All five agreed it was an outage. On the team question, four were at least 96 percent sure it belonged to platform, and Clef said 78. With a 0.9 bar for routing on its own, Clef's answer sends the ticket to a person. That is the reason the threshold lives in your code, and the reason you test the model you actually run. Version 0.3 followed on October 12th with audio and video for Clef-omni.
Obie also released two smaller gems that build on top of it. decide turns answers into a policy, a rule over the probabilities, a floor, a timeout, and an explicit choice to fail open or fail closed. feelings turns them into Ruby, with Feelings(email).like?("spam") and most_like for picking among options. Transport, policy, and language, each in its own small gem.
Conventions Enforced
Last edition Obie hinted he was building "a convention-driven framework for programmers who plan to remain programmers." He’s calling it Impatient Programming, and it took shape at Rails World, partly in conversation with David.
"We didn't totally see eye to eye on a lot of things, especially around the future of Rails for teams," Obie wrote. But one thing David insisted on was "100% spot-on," shippable code, action over talk. "So I took action." He took the 29 rules of Extreme Programming from 1999 and revisited each one for teams where agents write most of the code. "Agents buried every codebase under unstructured English prompts, so we put the conventions back and let machines enforce them."
The argument is that both failures XP answered are back. Big design up front returned as machine-generated plans nobody reads, and cowboy coding returned as vibe coding. The rules that are public so far show how it is shaping up. Write the Contract, a numbered, executable statement of what each component must do, detailed enough that the code can be deleted and regenerated from it. Keep it regenerable, and regenerate when it's worth it. Standards are enforced by machines. Every test must prove it's worth keeping, and mutation testing decides which ones stay.
The Contract is the "rock-solid contract layer" Obie predicted last edition, and it answers Sam Ruby's concern that regeneration is fine for a major version and awkward for a security patch. You don't regenerate everything. You regenerate the components where the Contract is strong enough to vouch for the result.
Stephen Margheim, who works with Obie at ZAR, wrote an account of where the method comes from. In Code Is Cheap Now, he argues that cheap code makes design judgment more valuable, not less, because a better pattern can now be applied across a whole codebase at once.
His method has two phases. Expand, by having the agent build candidate solutions, then contract, by folding what you learned back into the system, reusing primitives and deleting the state and conditionals you didn't need. Redundant nil checks and fallbacks for impossible states are worse than clutter, because they teach the next session that impossible cases happen. "As far as the agent is concerned, the code is the truth."
The Gates
The Impatient Programming open source side lives in tools4imps, and every tool is a merge check. exhale is the Ruby one, built on Prism and Herb, and it turns Stephen's contraction step into a merge check. Its first check finds duplicated code across Ruby and ERB, the copies agents leave behind from code generation sprawl.
Version 0.2 added a complexity gate that fails a pull request only when it makes a method harder to follow, and tells your agent which lines to pull out. It "judges the change, never the legacy," so an old Rails app can turn it on today without a cleanup sprint. Deliberate exceptions get written into the Contract with a reason, and an exception that goes stale fails the build.
qualm is the subjective gate. It asks Jev ten typed questions about each changed file and fails when a reviewer would likely push back on it, with the other nine answers saying why, including whether the change added copies or guards against impossible states. No LLM runs inside it, and Obie is upfront that its threshold was tuned on a single codebase.
Every tool holds itself to its own rules. exhale carries 82 numbered obligations, each with a tagged test, and its mutation gate killed all 340 deliberate breaks before release.
After the Merge
Stephen's second piece points at what every check in this edition left out. A rare but widespread failure, links that returned 503 for accounts nobody had used yet, sat in production until a colleague's friend happened to hit it. Once someone asked, Claude found the pattern by sampling and curling recent links, and the provider shipped a fix within the hour.
"I don't need a 'software factory,'" he wrote. What he wants is a software foreman, an agent that learns what normal looks like across every part of the product, investigates whatever looks off, and comes back with evidence or a pull request. He is building a unified data lake so it has one place to look, with each watch defined as a SQL query across logs, app events, and business records. He expects it to be noisy at first, but suggests that is better than silence.
The last edition described Rails as one piece of a software factory, and I still think that's right. Stephen's point is that the factory needs someone overseeing it. Sam checks the compiler against the app, the decision models put a number on the model's call, and Obie's gates refuse the bad pull request. All of it happens before the merge. Watching what the software does after it ships is still mostly an open question, and it may be the next one worth working on.
Need to Know AI News
Top AI Companies Probing Tens of Thousands of Security Incidents Madison Mills reported that OpenAI and Anthropic were investigating tens of thousands of cases of frontier models bypassing guardrails, escaping sandboxes, and evading monitors. OpenAI said it was pausing training of its most capable models until it adds more safeguards.
Human Baselines for Benchmarks: AI Now Outperforms Junior Accountants Aden Barton paid 12 licensed CPAs to do month-end close tasks from Mercor's accounting benchmark. They averaged 37 percent accuracy, while Claude Opus 5 scored 100 percent in under ten minutes at about 2 percent of the cost.
The Top 100 Gen AI Consumer Apps, 7th Edition Olivia Moore added consumer spending data to a16z's ranking for the first time. A quarter of Americans now use AI daily, but only 4.5 percent pay for ChatGPT, Gemini, or Claude, and the top 1 percent of spenders account for nearly a fifth of all spend.
The Dot and the Swarm Ethan Mollick reversed his view that people must design how agent teams are organized, calling it "the Bitter Lesson applied to the org chart." He pointed to OpenAI's Navier-Stokes proof, produced in 88 hours by thousands of loosely coordinated agents.
Against the Personal Agents Theory of Everything Nathan Baschez argued the bigger shift is factories, not personal agents. Shared AI systems built for one recurring task let a team watch every run and improve it, so the same tinkering goes much deeper than it does in everyone's private setup.
Agents, Safely Harnessed Igor Aleksandrov moved his always-on agents to an isolated box with no keys, a firewall that blocks his home network, and Tailscale rules that let him reach the agents but not the reverse. He warned that Docker containers bypass host firewall rules unless blocked separately.
Highlights
Agent Skills
Rails Hyperdrive Albert Pazderin of Evil Martians released a development-only Rails engine that lets any gem ship skills for coding agents, installed through Bundler only when your Gemfile includes the gems they target, alongside an MCP server that answers from your running app. His case is that generic packs mislead, since "an agent told about Minitest conventions in an RSpec codebase is actively worse."
thoughtbot took the catalog route instead with 25 skills drawn from its style guides, and Steve Polito's own set slows the human down on purpose, because "offloading the implementation works. Offloading the understanding doesn't." Rob Race argued that AGENTS.md should describe your app and point to its docs, and his free architecture checkup prompt audits what an agent will inherit from an existing codebase. Ivan Blažević's plan_driven skips guidance altogether and enforces team rules in Ruby.
Computer Vision
Smart Avatar Cropping in Rails: Face Detection With YuNet, ONNX Runtime and ActiveStorage Alexey Vasiliev showed how to keep faces in frame when Rails crops avatars, without reaching for a cloud vision API he called "total overkill for calculating a simple 2D cropping box." He ran YuNet, a face detector under 2 MB, inside the Ruby process with the onnxruntime gem, and hooked it into a custom Active Storage analyzer that saves a crop box to each blob's metadata. Photos with no confident face fall back to a center crop. The post is an example of running a real ML model in plain Ruby, with no Python sidecar and no per-image bill.
Rails LLM Benchmarks
Agents on Rails: Stage 3 Alexander Baygeldin, Vladimir Dementyev, and Aibek Izhanov tested whether coding models can build on their own work, with each ticket in a fresh session on apps like Mastodon, Redmine, and Campfire. Claude Opus 5.5 scored highest at 65.3 percent, and GPT-6.1 Sol nearly matched GPT-6 Astra at about a sixth of the cost. None of the 17 finished helpdesk apps had a persistent production job queue.
The previous round found maximum reasoning effort helped GPT models far more than Claude or Gemini, and caught DeepSeek 4.1 Flash using an API key to look up the answers. The Rails World talks are also now online, including Kinsey Durham Grace on agent-proofing your codebase and Joël Quenneville on harness engineering.
Ruby MCP SDK
MCP Ruby SDK Reaches Tier 1 Koichi Ito announced that the official Model Context Protocol SDK for Ruby reached Tier 1, with full support for the latest specification and a 100 percent pass rate on the conformance tests. Ruby now sits in the top tier beside TypeScript, Python, C#, Go, and Rust, a step ahead of Java.
The 1.6 and 1.7 releases that followed went deep on OAuth, including letting a web app finish authorization in the same request that receives the redirect. The mcp gem has passed 11 million downloads. With RubyLLM 2.1 adding its own MCP client, Ruby is now well covered on both sides of the protocol.
Structured Extraction
Squishling Michael Carroll previewed a gem at XO Ruby NYC that treats code as "a cache for AI judgment." A squished method declares its purpose and an output schema, sends calls to an LLM through RubyLLM, and returns the same typed result whether Ruby or the model did the work, so you write real code only for the inputs that carry the volume.
In his talk, routing the common health records format to a parser and the rest to the model kept a 95 percent pass rate on 100 test records at 76 percent lower cost than sending everything to the LLM. The token bill becomes a way to measure tech debt.
Agent Governance
The Agent Wins Hiding Outside Your SDLC Brandon Casci argued that the easiest agent payoffs are in the chores around a product, like answering support email or setting up customer accounts, where the data already lives in the app and success is easy to judge. He built both as short RubyLLM agent classes running in Active Job, with no vector database or separate service. Every tool checks a policy object before it runs, asks a person to approve changes, and loses access if its production eval score drops.
Formal Verification
ruby-lean Sam Xifaras built an executable model of Ruby in the Lean theorem prover, tested against CRuby, and proved that programs passing his checker for a small subset of Sorbet's type rules can't hit a family of type errors at runtime. Untrusted Ruby code proposes each type derivation, and a small trusted checker in Lean verifies it. Coding agents wrote almost all of the Lean over two and a half months on a $9,000 token budget, but the hardest proof needed him to define the theorems and the approach.
Agent Interoperability
a2a-rails Changquan Cui released a gem that publishes an existing Rails app as an agent other agents can call over the Agent2Agent protocol. A generator adds the agent card and endpoint, and a small DSL exposes your business logic as named skills, with handlers written as plain Ruby classes that never touch protocol objects. His write-up, in Japanese, walks through it from install to a completed task.
Agentic Context
How We Made an 11-Year-Old Rails App Ready for AI Coding Agents Igor Froehner walked through letting several agents work on one legacy Rails app at once without colliding over files, databases, or ports. Each task gets its own git worktree, with ports derived from its index, its own Postgres and Redis in Docker, and a copy of an anonymized database. A bin/worktree script refuses to delete a worktree with unpushed work, and a short agent skill explains the setup.
Brunch Maciej Ciemborowicz built a gem that gives every git branch and worktree its own Docker Compose environment, started and stopped by git hooks as you switch. Each worktree gets its own port, so several coding agents can run the same Rails app on different branches without stepping on each other. His write-up covers the setup and the missing piece, since git still has no hooks for creating worktrees.
Agentic Coding
The Senior, the Junior and the Mediocre Abdelkader Boudih suggested that AI added a third kind of engineer, the mediocre, who borrows confidence and vocabulary from a model. His evidence came from crates.io, where 5,702 new crates declare a recent Rust version but still start on the old edition, a sign that a model wrote the config file. His earlier Republic of Slop followed a 4,271 commit pull request that reviewers read, objected to, and formally blocked, and that merged anyway. Reviewers need merge-blocking power, not just comment rights.
Agentic Security
Rails Security in Times of AI-Driven Scanners Mario Alberto Chávez found that scanners hitting his small Rails apps had stopped probing random WordPress paths and were going after Rails credentials, master keys, and the exact stack each app ran. His defense pairs fail2ban-style bans and Cloudflare rules built from that traffic with two agent skills, one that enforces tenant-scoped queries before every commit and one that audits headers, CSP, cookies, and rate limits.
Rails CVE Avi Flombaum built a service that watches the official Rails security advisories and sends each one to your email or a signed webhook, along with an investigation brief your coding agent can run inside the repo. The brief has the agent check Gemfile.lock, report whether the app is affected with file and line evidence, and propose the smallest fix, asking your approval before it changes anything.
Vector & Hybrid Search
Noiseless Abdelkader Boudih answered Basecamp's new Active Search by open-sourcing the async search layer for Rails he started back in 2021. It speaks HTTP directly to OpenSearch, Elasticsearch, Typesense, and PostgreSQL, compiles each query for its backend, and supports vector and hybrid search, pgvector included. In the launch post 100 slow searches dropped from 10.6 seconds run in sequence to 139 milliseconds run concurrently.
Core Ruby
Introducing Override and Prune in RubyGems and Bundler 4.1 Hiroshi Shibata shared two opt-in features in the Bundler 4.1 beta. override lets your Gemfile rewrite a dependency's constraints, even deep in the tree, so a stale upper bound on a gem or on Ruby itself no longer blocks an upgrade, and it can drop or swap a dependency you never load. prune replaces the cleanup Rails Dockerfiles do by hand, deleting caches and git checkouts Bundler can regenerate. Overrides stay in the Gemfile and never reach the lockfile, so leave a comment saying why.
Critical Rails
Hot Cell 1.0 Mike Dalessio released the 37signals gems that move Active Storage's image, PDF, and video processing out of your Rails app into a sidecar container with no network, no credentials, and nothing worth stealing. Each file is passed in as a descriptor and handled by a forked worker under strict limits, for about 3.4 milliseconds per call in Basecamp's production.
After this summer's critical Active Storage vulnerability was announced, researchers worked out the attack within hours, and Mike's answer is to shrink the blast radius rather than wait for libvips to get safer. Adopting it is a configuration change, though the Active Storage gems need the unreleased Rails 8.2.
Agentic Deployments
Hatchbox MCP Collin Jilbert shared Hatchbox's MCP server, which lets a coding agent inspect and run your apps, domains, databases, servers, and backups, with every tool marked read-only or destructive. It also ships a Claude Code skill that moves a Rails app from Heroku to Hatchbox. The skill plans first and waits for your approval, then creates the app, databases, env vars, and cron jobs, rehearses the deploy and data transfer, and leaves the Heroku app untouched so you can roll back.
SF Ruby Conference
SF Ruby Conference The San Francisco Ruby Conference returns to SFJAZZ November 10th to 12th, with an AI-heavy first day, an AI-light second day, and a day of community events across the city. Two tracks run side by side, one for startups and one for larger companies, and whichever audience is off stage breaks into small conversation groups, including one on agentic coding practices. Single-day passes have sold out, and Ruby AI News readers get a discount with the code RUBYAI, already applied with the link above.
Jobs & Opportunities
Over 100 Rubyists have already started looking for their next opportunity with Ruby Roles. Sign in with GitHub, answer five questions about your level, how you like to work, where you can be based, and your salary floor, and you get your three best matches right away. After that it sends at most one new role each business day, and only when something actually clears the bar. It is tracking 1,910 open Ruby-related roles right now, and about two out of three mention AI somewhere in the description.
If you read the stories above, you already know how the matching works. Ruby Roles runs on RubyLLM judgments and Jev. Each posting is read once by a decision model that pulls out the seniority, the work style, the salary, and how central Ruby really is. Your best candidates are then judged against your answers and your public Ruby repositories, with a fit on a five step scale and a probability that you would apply, for a fraction of a cent each. It is free, SerpApi sponsors it, and the feedback button on every page comes straight to me.
One Last Thing
boxd This edition had worktrees, Docker sidecars, and an isolated box for running agents safely. boxd skips all of it and hands every agent its own Linux computer, hardware-isolated and ready in under 10 milliseconds. You set a machine up once with your tools and data, then fork it mid-run, memory and all, in under 200 milliseconds, roll it back to a checkpoint, or let it hibernate until traffic wakes it. A sleeping machine costs only its disk. New accounts get €30 in credits (US accounts are waitlisted for now), so you can give your Rails app and its agents a computer each and see what happens. [h/t to Chad Fowler for surfacing this]
That’s all for this edition! Be sure to reach out if you have any stories, content, jobs, or events you want featured in the newsletter.