1 min read
▶ Video
What we learned shipping AI agents to production
Agents are fun in a demo and humbling in production. Here are the guardrails that made ours reliable enough to trust.
Posts tagged #ai
#actioncable 1
#agents 2
#ai 9
#angularjs 1
#ansible 2
#architecture 4
#aws 1
#bitcoin 2
#capistrano 1
#css 2
#dci 1
#design-patterns 1
#devops 8
#docker 2
#ecommerce 4
#elasticsearch 1
#engineering 5
#frontend 5
#haml 1
#i18n 1
#infrastructure 3
#javascript 1
#jekyll 1
#kubernetes 1
#llm 6
#lrug 1
#mongodb 2
#performance 3
#postgres 3
#postgresql 7
#process 1
#product 1
#production 1
#rack 1
#rag 1
#rails 26
#redis 1
#ruby 38
#sass 3
#search 4
#security 2
#sidekiq 1
#testing 2
#trading 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.
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.
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.
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.
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.
7 min read
Vector search at scale: pgvector vs dedicated stores
Once your semantic search outgrows a toy dataset, the question arrives: stay with pgvector in Postgres, or move to a dedicated vector database like Pinecone, Qdrant, or Weaviate? A deep-dive on what actually changes at scale, what you give up by leaving Postgres, and how to decide without over-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.
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.