Reading Roundup: Foundations You Forgot to Check

Database indexes, version managers, credentials, LLM visibility, and the conventions that make Rails work for agents.

Hey there,

This week’s reading felt like going back and double-checking the foundations. Not because anything was broken, but because there’s a surprising amount of depth in the things we set up once and never think about again. How database indexes actually work under the hood. Which Ruby version manager you should be using in 2026. Where your credentials live and whether you should care. And then two articles that look forward: making your site visible to LLMs, and a Claude Code skill that codifies the Rails conventions most of us carry around in our heads.

Stop Using RVM: The Ultimate Guide to Ruby Version Managers
A straightforward comparison of RVM, rbenv, chruby, asdf, mise, and direnv, with the conclusion that mise is the best choice for new setups and rbenv remains solid if you only need Ruby.
https://norvilis.com/stop-using-rvm-the-ultimate-guide-to-ruby-version-managers/

How LinkedIn Feed Uses LLMs to Serve 1.3 Billion Users
LinkedIn replaced five separate feed retrieval systems with a single LLM-powered dual encoder model, converting structured profile data into embeddings that serve recommendations in under 50 milliseconds.

How LinkedIn Feed Uses LLMs to Serve 1.3 Billion Users

Use Rails Combined Credentials
Rails edge (expected in 8.2) introduces Rails.app.creds, a combined credentials API that checks ENV first and falls back to encrypted credentials, so you never need to know or care where a secret is stored.
https://andycroll.com/ruby/use-rails-combined-credentials/

Making Your Site Visible to LLMs: 6 Techniques That Work, 8 That Don’t
Evil Martians’ practical guide to LLM discoverability: ship clean Markdown at every URL via .md routes, add an llms.txt file, use Accept: text/markdown content negotiation, and skip the meta tags nobody reads.
https://evilmartians.com/chronicles/how-to-make-your-website-visible-to-llms

Things You Didn’t Know About Indexes
A clear walkthrough of database indexing beyond the basics: composite index column ordering, why functions defeat your index, and three index types most developers never reach for (functional, partial, and covering indexes).
https://jon.chrt.dev/2026/04/15/things-you-didnt-know-about-indexes.html

Bonus: Julian Rubisch’s Rails Classic Claude Code Skill
A Claude Code skill that encodes the 37signals/classic Rails style: rich domain models, CRUD-only controllers, state-as-records instead of booleans, concerns named as adjectives, Minitest with fixtures, and no service objects.
https://github.com/julianrubisch/skills/blob/main/jr-rails-classic/SKILL.md

Quick notes and actionables

• mise seems to be the default recommendation these days: If you’re setting up a new machine, it’s probably the right call. It’s asdf rewritten in Rust, reads your existing .tool-versions and .ruby-version files without changes, and handles environment variables too, which means you can probably drop direnv. That said, I’m still on asdf myself. It works, I’ve never had a reason to switch, and “it works” is a perfectly valid reason to stay put. If your terminal startup isn’t slow and you’re not managing a dozen runtimes, there’s no urgency here.

• The Evil Martians LLM article is worth acting on, and I tested it: I used an LLM to search for information I knew was on a side project of mine. It didn’t find it at first, so I guided it to the URL. Minutes later I could see the site being crawled by the same LLM, hitting every page in the sitemap. The key takeaway from the article is honest: no major LLM provider has committed to reading llms.txt or .md routes automatically. The value is in what happens when a human or a tool points an LLM at your URL, which happens more often than you’d think. The six techniques that work are all standard web infrastructure. The eight that don’t are mostly invented meta tags citing other blog posts as evidence. That honesty alone makes it worth reading.

• The combined credentials API in Rails 8.2 is going to clean up a lot of codebases: The pattern of mixing ENV.fetch and credentials.dig throughout a codebase is messy and everyone knows it. Rails.app.creds.require(:stripe, :api_key) checks ENV first (mapping nested keys to double-underscored names like STRIPE__API_KEY), then falls back to encrypted credentials. You can move secrets between ENV and encrypted files without changing application code. It’s on Rails edge now, expected in 8.2.

• The index article is the kind of thing I wish I’d read earlier in my career: The composite index ordering explanation is particularly good. If you have an index on (type_1, type_2), queries on type_2 alone won’t use it because type_2 values are scattered across the tree. Partial indexes are the one I think most developers underuse: if you’re soft-deleting records, an index on email WHERE deleted_at IS NULL skips all the dead rows you’re never querying anyway. And covering indexes with INCLUDE let the database answer queries entirely from the index without touching the table at all.

• The LinkedIn feed architecture is fascinating even if you’ll never build at that scale: The detail that caught me was how LLMs can’t understand numerical magnitude. Raw engagement counts like “views:12345” had essentially zero correlation with embedding similarity. Converting to percentile buckets (<view_percentile>71</view_percentile>) gave the model something learnable and improved recall by 15%. The other insight: filtering training data to only positively-engaged posts (removing scroll-pasts) reduced memory by 37% and made training 2.6x faster. Less data, better model.

• The Rails Classic skill is worth reading even if you never install it: I haven’t used it in a project, but reading through the rules and conventions gave me a lot to think about. State-as-records instead of booleans (a Card::Closure record rather than a closed column), concerns named as adjectives (Closeable, Publishable), REST mapping that turns every action into a sub-resource (POST /cards/:id/closure instead of PATCH /cards/:id/close). These are conventions that exist in the heads of experienced Rails developers, and encoding them as a Claude Code skill is a strong argument for why Rails and agentic coding are a natural fit. The conventions are specific enough to constrain an agent without being so rigid that they break on edge cases. One thing that stood out: the explicit preference for Minitest over RSpec. I’m fairly sure I listened to a podcast a while back where the creator of RSpec himself suggested using Minitest. There seems to be a quiet shift happening here, and I’m curious what people think. What’s driving it? Is it the speed? The simplicity? The fact that fixtures play better with agents than factories? I’d genuinely like to hear where people land on this.

Plenty to chew on this week. If you end up building something off the back of any of these, I want to hear about it. P.S. You can see everything I’ve been reading at dcyoung.dev/bookmarks.