// Topics / LLMs

LLMs

    AI Video Applications in Practice Video AI is practical for scoped workflows. This post covers what works, how to design for reliability, and where human review still matters. llm ai production Running AI Locally: A Practical Guide for Teams Who Care About Control Local AI is no longer a hobby project. How to set it up properly: provider abstraction, versioned models, eval harnesses, and a cloud fallback. llm development privacy AI Docs That Don't Lie to Your Users Most AI documentation systems retrieve the wrong version, hallucinate details, and never admit uncertainty. Here's how to build one that actually helps. engineering ai llm Stop Fine-Tuning Models You Haven't Bothered to Prompt Properly 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. llm ai opinion Your AI Pipeline Is Just ETL With Extra Steps (And That's Fine) AI data pipelines are ETL with a retrieval layer bolted on. The discipline is the same as always: detect change, chunk intelligently, keep indexes fresh. data ai infrastructure MCP in Practice: Building Tool Servers in Go Model Context Protocol promises to standardize how AI talks to tools. I built an MCP server in Go to see if the promise holds up. Here's what I found. agents ai go Video Understanding AI: What Actually Works I pointed a video understanding pipeline at 200 hours of meeting recordings. The results taught me more about pipeline design than about meetings. llm ai data Reasoning Models in Production: A Practical Guide 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. llm production ai Picking an AI Model for Production (Late 2024) 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. ai llm reflection AI Cost Benchmarking: What Your Bill Actually Tells You 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. ai cost llm RAG Retrieval That Actually Works Most RAG failures are retrieval failures. Hybrid search, smarter chunking, query expansion, and reranking -- measured separately from generation. llm go How I Actually Test LLM Features 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. llm testing ai The Best Model Is the Smallest One That Works 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. llm ai performance Stop Stuffing Your Context Window 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. llm ai architecture Function Calling Patterns That Survive Production 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. llm ai go Claude 3.5 Sonnet Analysis: Cost, Coding, and Model Routing Claude 3.5 Sonnet changes model routing math for coding, cost, latency, and production AI workloads. llm ai reflection Building Voice AI That People Actually Use Voice AI is ready to ship. The hard parts are latency, interruptions, and knowing when voice is the wrong interface. Here's how I approach it. llm ai go GPT-4o Changed the Interface, Not the Hard Part OpenAI shipped a model that sees, hears, and talks back in real time. The demos look magical. The architecture implications are where it gets interesting. llm architecture ai LLM Structured Output in Go: JSON Schema, Validation, Retries How to get reliable JSON from LLMs in Go with schemas, validation, repair loops, and typed contracts. llm api go LLM Prompt Caching in Go: Cut Costs Without Breaking Things Caching LLM responses is the highest-leverage optimization most teams skip. How I implement it in Go -- keys, invalidation, and safety patterns. llm performance go Why I Run Multiple Models in Production 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. ai architecture llm Claude 3 First Impressions: Three Models, One Decision Framework Anthropic shipped three models instead of one. That is actually the most interesting part of the release. llm ai LLM Evaluation: Stop Shipping on Vibes 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. ai llm testing Architecting AI-Native Applications (Without the Delusion) AI-native apps are fundamentally different from a model bolted onto a CRUD app. How I structure them -- with code, layers, and hard-won opinions. architecture ai engineering Stop Paying OpenAI to Test Your Prompts Local LLMs are finally good enough for development. Use them for iteration, keep the API bills for production. llm engineering go AI Engineering Is Its Own Discipline Now 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. ai hiring llm Multimodal AI: Five Use Cases That Actually Work (and Three That Do Not) GPT-4V is out and everyone is building vision features. After testing it across real workflows, here is what ships well and what falls apart. ai llm business Two Weeks With the Assistants API: What I Like, What I Hate I built three things with the Assistants API. One shipped, one got scrapped, and one taught me where the API's limits really are. llm ai go OpenAI DevDay Happened and I Have Opinions 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. llm ai architecture LLM Security: A Field Guide for People Who Ship Things LLMs bring security failure modes most teams aren't defending against. Prompt injection, data leakage, tool abuse, and cost attacks are exploitable today. security llm ai AI Technical Debt Is Eating Your Codebase (You Just Cannot See It Yet) 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. ai technical-debt engineering Agent Architecture Patterns That Actually Work in Production Most agent demos are impressive. Most agent production systems are not. Here is what separates the two. ai agents llm LLM Observability: Your Existing Monitoring Is Not Enough Traditional monitoring says the service is up. It won't tell you the model started returning garbage last Tuesday. How to actually observe LLM systems. observability llm ai What I Learned Building AI Features Into a Fintech Product Building AI features at a fintech taught me the hard part isn't the model: it's defining quality, handling failures, and not shipping a demo as a product. ai strategy business Your LLM Bill Is Your Own Fault Everyone's complaining about LLM costs. Almost nobody has done the basics: caching, model routing, or even measuring what they're spending per feature. ai cost llm Embedding Models Compared: Retrieval Quality, Cost, and Latency A practical embedding model comparison for retrieval quality, vector size, latency, cost, and self-hosting tradeoffs. llm ai go Building Semantic Search in Go: From Embeddings to Production A hands-on walkthrough of building semantic search with Go, OpenAI embeddings, and pgvector -- chunking, hybrid retrieval, and the gotchas I hit. ai llm go Fine-Tuning vs. Prompting: A Decision Framework Most teams should exhaust prompting before they even think about fine-tuning. Here's how to decide which lever to pull. ai llm LangChain Is the New ORM: Convenient Until It Is Not LangChain promises to simplify LLM development. Instead it adds abstraction layers you will fight against the moment your use case gets real. llm ai opinion RAG Patterns That Actually Work in Production 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. llm ai go Vector Databases: What They Actually Are and When You Need One A practical guide to vector databases -- what they store, how similarity search works, and the architectural decisions that matter in production. llm ai go Claude vs GPT: A User's Honest Take Anthropic's Claude takes a different approach to AI safety. Here is how it compares to GPT in practice, from someone using both daily. ai llm My First Week Building with GPT-4 GPT-4 landed and everything changed. What I learned in the first week of building with it, and the architecture decisions that followed. ai llm architecture Prompt Engineering Is Not Engineering The term 'prompt engineering' oversells what is essentially clear writing. It is a useful skill, not a discipline. ai llm opinion LLM Integration Patterns That Actually Survive Production Practical patterns for integrating LLMs into real applications -- prompt management, structured outputs, caching, fallbacks, and tool use -- with Go examples. ai llm go AI in Production Is Just Engineering. Treat It That Way. ChatGPT changed expectations overnight, but shipping AI features that actually work is an engineering problem, not a model problem. ai production engineering Five Days With ChatGPT First impressions of ChatGPT from a working engineer. It is not a search engine, it is not a colleague, and it is definitely not a replacement. But it is something. ai llm developer-experience Your Video Infrastructure Isn't Ready for What's Coming Most companies building video calling are making the same architecture mistakes. What I keep seeing, and how to fix it before your SFUs fall over. llm infrastructure architecture