LLM

Local AI is no longer a hobby project. Here's how to set it up properly: provider abstraction, versioned models, evaluation harnesses, and cloud fallback for when local isn't enough.

Fine-tuning is the goto move for teams who skipped the basics. Most of the time, better prompts and proper retrieval solve the actual problem.

Reasoning models are powerful but expensive and slow. Here's how I integrate them in Go services with routing, async patterns, and cost controls that actually work.

There's no best model. There's the model that fits your workload, latency budget, cost constraint, and ops tolerance. Here's how to compare them.

Price-per-token is the least useful number on your AI bill. Real cost benchmarking starts with your workload, not a provider's pricing page.

Most RAG failures are retrieval failures. Fixing them requires hybrid search, smarter chunking, query expansion, and reranking -- measured independently from generation.

LLM outputs are non-deterministic. That doesn't mean you can't test them rigorously. Here's the layered testing approach I use in production.

Everyone reaches for GPT-4 by default. Most production tasks don't need it. Small models are faster, cheaper, and often better when the task is well-defined.

Bigger context windows aren't an excuse to stop thinking about what goes into them. Most teams are paying for irrelevant tokens and wondering why quality degrades.

Function calling is how LLMs touch real systems. Treat tools like APIs, arguments like untrusted input, and permissions like the model is an intern with root access.

Anthropic's Claude 3.5 Sonnet isn't just another model release. It's a bet that the mid-tier can handle what you've been paying top-tier prices for.

LLMs generate text, not data structures. Here are the patterns I use in Go to get reliable, validated JSON out of models -- with schemas, retries, and repair loops.

Caching LLM responses is the highest-leverage optimization most teams are not doing. Here is how I implement it in Go, with real patterns for keys, invalidation, and safety.

Betting on a single model provider is like having a single database with no failover. Here is why multi-model is the only sane production strategy.

Anthropic shipped three models instead of one. That is actually the most interesting part of the release.

Your LLM feature looks great in demos and breaks in production. Here is how to build an evaluation loop that catches regressions before your users do.

The architecture of an AI-native app is fundamentally different from bolting a model onto a CRUD app. Here is how I structure them -- with code, layers, and hard-won opinions.

Local LLMs are finally good enough for development. Use them for iteration, keep the API bills for production.

AI engineering is not ML research with a product hat. It is the discipline of making models behave in production -- and it demands its own skill set.

I built three things with the Assistants API. One shipped, one got scrapped, and one taught me where the API's limits really are.

OpenAI DevDay was not just a product launch. It was a platform play that changes the build-vs-buy calculus for every team shipping AI features.

LLMs introduce security failure modes that most teams are not defending against. Prompt injection, data leakage, tool abuse, and cost attacks are real and exploitable today.

AI features create a new species of technical debt that hides in prompts, data pipelines, and model versions. By the time you notice it, the cleanup bill is brutal.

Most agent demos are impressive. Most agent production systems are not. Here is what separates the two.

Traditional monitoring tells you the service is up. It doesn't tell you the model started confidently returning garbage last Tuesday. Here's how to actually observe LLM systems.

Building AI features at a fintech infrastructure company taught me that the hard part isn't the model. It's defining quality, handling failures gracefully, and resisting the urge to ship a demo as a product.

Everyone's complaining about LLM costs. Almost nobody has done the basics: caching, model routing, or even measuring what they're spending per feature.

Most teams should exhaust prompting before they even think about fine-tuning. Here's how to decide which lever to pull.

LangChain promises to simplify LLM development. Instead it adds abstraction layers you will fight against the moment your use case gets real.

RAG is the default architecture for grounding LLMs in private data. Here are the patterns that survive real traffic, with Go examples from production systems.

Anthropic's Claude takes a different approach to AI safety. Here is how it compares to GPT in practice, from someone using both daily.

GPT-4 landed and everything changed. What I learned in the first week of building with it, and the architecture decisions that followed.

The term 'prompt engineering' oversells what is essentially clear writing. It is a useful skill, not a discipline.

Practical patterns for integrating LLMs into real applications -- prompt management, structured outputs, caching, fallbacks, and tool use -- with Go examples.