AI

By early March 2026, the AI startup market looks less like a gold rush and more like a durable industry with clear pressure points. This post lays out where leverage sits, what buyers reward, and what durable execution looks like now.

As of late February 2026, AI security is defined by adaptive attacks and layered, operational defenses.

As of mid-February 2026, AI team structures have stabilized into a few workable patterns. This guide explains the models, tradeoffs, and roles that hold up in practice.

A pragmatic look at AI cost trends in early February 2026, plus what to do about them.

Regulation isn't a future problem anymore. It's showing up in procurement, security reviews, and internal sign-off. The teams that treat compliance as engineering will ship faster than the ones scrambling to bolt it on.

As of late January 2026, AI-native architecture is a stable discipline with repeatable patterns for delivery, safety, and change management.

Reliable agents aren't prompted into existence. They're engineered -- with bounded tools, validation at every step, explicit recovery paths, and the same discipline you'd apply to any production system. Here's how I build them in Go.

Video AI is practical for scoped workflows. This post covers what works, how to design for reliability, and where human review still matters.

Less hype, more plumbing. Agents get real but stay bounded. Routing beats monolithic models. Governance lands on the critical path. And the teams that win will be the ones that treat AI like software, not magic.

A year-end look at what actually happened in AI -- not the hype, but the operational shift. The novelty phase is over. The infrastructure phase has begun.

The most important thing that happened to AI in 2025 wasn't a model release. It was the shift from 'what can it do' to 'how do we run it.' That's progress.

The technology works. The pilots work. What doesn't work is going from five demos to fifty production features without an operating model. That's not an AI problem -- it's a management problem.

Your AI system can return 200 OK and still be wrong, unsafe, or confidently hallucinating. Here's how to detect, contain, and learn from AI incidents -- drawing from the same IR principles that work for traditional systems.

AI debt doesn't look like normal tech debt. It hides in prompts nobody owns, evals nobody runs, and data pipelines nobody watches. By the time you notice, every change feels dangerous.

Individual AI speedups are a distraction. The real gains come from treating AI as team infrastructure -- embedded in docs, decisions, and onboarding.

Most AI ROI calculations are fantasy. Here's how to measure honestly: pick one workflow, capture the full cost, tie benefits to outcomes the business already tracks, and report a range instead of a single number.

Privacy in AI systems fails in the implementation details -- what gets logged, who can replay prompts, how long artifacts linger. Treat it as infrastructure, not a compliance checkbox.

AI coding assistants are useful when you treat them like a fast, literal junior teammate. Give them constraints, review their output, and stop expecting architectural insight.

The trick to AI workflow automation is simple: let the model decide, let deterministic code act, and never confuse the two.

Most AI documentation systems retrieve the wrong version, hallucinate details, and never admit uncertainty. Here's how to build one that actually helps.

Engagement metrics tell you people clicked. They tell you nothing about whether your AI feature actually helped anyone do anything.

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.

Most AI support systems are built to deflect tickets. The ones that actually work are built around escalation, grounding, and the simple idea that customers aren't idiots.

AI data pipelines aren't some new paradigm. They're ETL with a retrieval layer bolted on. The discipline that makes them work is the same discipline that has always made pipelines work: detect change, chunk intelligently, keep indexes fresh.

Multi-agent systems aren't magic. They're distributed systems with all the usual coordination headaches. Here are the four patterns I've seen work, and when each one falls apart.

AI systems are exposed APIs with real blast radius. The threats are injection, leakage, and tool misuse. The defenses are the same ones we've always needed -- just applied to a new surface.

Offline evals are necessary but not sufficient. Here's how I test AI features in production with shadow mode, canaries, and rollback automation -- with Go code.

Traditional monitoring will tell you your AI service is up. It won't tell you it's returning confident garbage. Here's what observability actually looks like for AI.

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.

Governance that blocks delivery is broken. Governance that makes 'yes' safe and fast is a competitive advantage. Here's how to build the second kind.

I pointed a video understanding pipeline at 200 hours of meeting recordings. The results taught me more about pipeline design than about meetings.

I've been running AI code review on real PRs for months. It catches some real bugs. It also generates a staggering amount of useless commentary.

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.

The AI hype cycle is over. 2025 is about the teams who can make this stuff actually work in production -- repeatably, measurably, and without burning money.

The AI advantage in 2025 goes to teams that ship measurable workflows, not teams that chase capabilities. The gap is discipline, not technology.

2024 was the year AI stopped being exciting and started being useful. The demo phase ended. The production phase began. Discipline won.

AI infrastructure at scale is just infrastructure. The same boring patterns -- gateways, caching, circuit breakers, budget enforcement -- solve the same boring problems.

Most AI team failures come from unclear ownership and weak evaluation, not missing talent. Structure and discipline beat hiring sprees.

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 safety in production isn't a research problem. It's defense in depth, the same way cyber defense works -- layered controls, assumed breach, observable boundaries.

Single-prompt agents break on real tasks. Plan-execute-replan, orchestrated specialists, structured memory, and explicit recovery -- in Go -- are what actually works.

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 is a decent drafting assistant for technical docs. It's a terrible replacement for ownership.

I used LLMs to help migrate a 200K-line Go codebase. The mechanical parts went fast. Everything else was still hard.

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.

Compliance doesn't have to slow you down. But you have to build it into the system from day one, not bolt it on after the demo impresses the board.

Most enterprise AI projects die between the demo and production. The blockers aren't technical -- they're organizational. Here's what I keep seeing.

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.

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.

The AI tooling landscape is exploding. Most of it adds complexity without removing real friction. Here is how I decide what earns a spot in the stack.

AI agents that can take actions are fundamentally different from chatbots. The engineering bar must match the blast radius.

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.

A personal look back at 2023 -- watching AI reshape the industry in real time, and figuring out what matters next.

The GPU shortage is real, rate limits are a production constraint, and your AI demo is going to collapse under real traffic. Some annoyed thoughts on infrastructure realism.

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.

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.

After three months of tracking Copilot and GPT-4 usage across real projects, the productivity picture is messier than the marketing suggests.

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.

Responsible AI is not an ethics committee. It is operational risk management, and teams that treat it otherwise are building liabilities.

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.

Every roadmap I've seen this quarter has an AI feature. Most of them start with the wrong question. Start with the user problem, not the model.

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.

I benchmarked five embedding models against the same retrieval task. The results challenged some of my assumptions about model size, cost, and quality.

Everyone has an AI startup now. Having been through two accelerators and founded two companies, I can tell you: most of these will not survive the year.

A hands-on walkthrough of building semantic search with Go, OpenAI embeddings, and pgvector. Includes chunking strategies, hybrid retrieval, and the gotchas I hit along the way.

After three months of using AI-assisted code review across multiple projects, here's what actually works and what's just noise.

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.

A practical guide to vector databases -- what they store, how similarity search works, and the architectural decisions that matter in production.

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 safety is not a philosophy problem for engineers. It is reliability, security, and accountability applied to a new kind of system.

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.

ChatGPT changed expectations overnight, but shipping AI features that actually work is an engineering problem, not a model problem.

A personal look back at 2022: building through the downturn, watching ChatGPT arrive, and what the year taught me about building things that last.

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.

Six months with Copilot in real projects. What it actually helps with, where it quietly makes things worse, and why the productivity claims are overblown.

I got early access to GitHub Copilot's technical preview. Here's what it actually does well, what it gets wrong, and why I'm cautiously interested.