Skip to content
← All posts

Posts tagged #engineering

#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

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
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

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