Skip to content
← All posts

Posts tagged #ai

#actioncable 1 #activestorage 1 #agents 6 #ai 21 #angularjs 1 #ansible 2 #api 1 #architecture 8 #aws 1 #bitcoin 2 #capistrano 1 #ci 1 #cost 1 #css 2 #dci 1 #design-patterns 1 #devops 12 #docker 3 #ecommerce 8 #edge 1 #elasticsearch 3 #engineering 10 #frontend 12 #graphql 1 #haml 1 #hotwire 1 #i18n 1 #infrastructure 5 #javascript 8 #jekyll 1 #jquery 1 #kubernetes 1 #llm 18 #lrug 1 #mongodb 2 #monitoring 1 #observability 1 #payments 1 #performance 4 #postgres 4 #postgresql 11 #privacy 1 #process 1 #product 1 #production 5 #rack 2 #rag 1 #rails 44 #react 1 #redis 1 #redux 1 #ruby 55 #sass 3 #search 7 #security 5 #sidekiq 1 #stimulus 1 #testing 5 #tooling 1 #trading 1 #turbolinks 1 #typescript 1 #ux 1 #webpack 1 #websockets 1
8 min read

Building reliable tools for LLMs

Function calling, agents, and MCP all rest on the same thing: tools an LLM can invoke. But a tool built for a non-deterministic, fallible caller needs different design than one built for code. A deep-dive on what makes a tool reliable for an LLM — naming, scope, validation, error messages it can recover from, and the safety that can't live in the model.

#ai #llm #agents #engineering
7 min read

The AI-native Rails stack in 2026

Put the pieces together — the no-Redis Solid stack, Kamal, pgvector, and the hard-won disciplines of building with LLMs — and a coherent picture emerges: Rails is an outstanding host for AI-native applications, precisely because it lets a small team build and run both the app and its AI features. A synthesis of where the stack stands.

#ruby #rails #ai #llm #architecture
6 min read

Multi-agent systems: orchestration patterns

Once single agents work, the temptation is to wire several together — a researcher, a writer, a critic — and let them collaborate. Sometimes that's powerful; often it's complexity you didn't need. A deep-dive on the orchestration patterns for multi-agent systems, when they earn their keep, and the failure modes that multiply when agents multiply.

#ai #llm #agents #architecture
7 min read

Spec-driven development with AI agents

When an AI agent does the implementation, the specification becomes the highest-leverage artifact in the project — a clear spec produces good code, a vague one produces a confident mess. A deep-dive on why spec-driven development has resurged in the agent era, what a good spec for an agent looks like, and how the workflow actually changes.

#ai #llm #agents #engineering
7 min read

Designing human-in-the-loop workflows

The most reliable AI systems in production aren't fully autonomous — they keep a human at the decision points that matter. But 'human in the loop' is easy to do badly: rubber-stamp approvals, alert fatigue, humans blamed for the model's mistakes. A deep-dive on designing the human-AI division of labour so both do what they're good at.

#ai #llm #product #engineering
7 min read

pgvector in production: lessons learned

I've championed pgvector as the sensible default for vector search. After running it in production, here's what the introductory tutorials leave out: index choice and its trade-offs, the recall-versus-speed dial, keeping embeddings in sync, and the operational realities that only show up at scale.

#postgres #ai #search #production
7 min read

Guardrails and evals for production agents

Putting an agent in production is harder than a single LLM call, because an agent is a loop with a multiplied failure surface — and you have to both contain it at runtime and measure it over time. A deep-dive on the two disciplines that make production agents trustworthy: guardrails that bound what an agent can do, and evals that test a whole trajectory, not a single output.

#ai #llm #agents #testing #production
6 min read

Fine-tuning vs RAG vs prompting: choosing in 2025

There are three ways to make an LLM do what your application needs — prompting, retrieval, and fine-tuning — and teams routinely reach for the wrong one. They solve different problems, and the costs differ enormously. A trend post on what each is actually for, and a decision order that saves you from over-engineering.

#ai #llm #rag #engineering
7 min read

Cost-control patterns for LLM-heavy apps

LLM calls are metered per token, so in an LLM-heavy app, cost is an engineering dimension you design for — not a bill you discover. A deep-dive on the patterns that keep it under control: model tiering, caching, token discipline, budgets, and the measurement that has to come before any of it.

#ai #llm #engineering #cost
6 min read

Agentic coding tools: a year-one review

A year ago, AI in the editor mostly meant autocomplete. Now we have tools that edit across files, run commands, and work through a task while you watch. After a year of using them in real work, here's an honest review: what they're genuinely good at, where they fall down, and how they change the job.

#ai #llm #tooling #engineering
7 min read

Self-hosting open LLMs: Llama and friends

Open-weight models like Llama 2 and Mistral mean you can now run a capable LLM on your own infrastructure instead of calling someone's API. A look at why you'd want to — privacy, cost, control — what it actually costs you in ops, and the honest question of whether you should.

#ai #llm #infrastructure
7 min read

Function calling: letting the model use your tools

Function calling lets an LLM ask your code to run a function and use the result — turning a model that can only talk into one that can look things up and act. A deep-dive on how it actually works, why it's just structured output with a loop around it, and why you stay firmly in control of what actually runs.

#ai #llm #ruby #engineering
7 min read

Streaming LLM responses with Turbo Streams

An LLM call takes seconds, and a user staring at a spinner feels every one of them. Streaming the tokens as they generate turns dead wait into live text — and Turbo Streams is exactly the Rails primitive for pushing that text to the page. A deep-dive on wiring slow model output to a responsive UI.

#ruby #rails #ai #llm #hotwire