58 articles
AI agents write code faster than you can review it. If you don't write the tests first, you're just generating legacy code at scale.
Rendering streaming LLM responses and complex agent workflows breaks standard React patterns. Here's why the entire TanStack ecosystem was the right choice.
An agent with every tool is a liability. Here's how I design scopes, budgets, and audit trails so agents stay useful without being dangerous.
If you can't measure your agent, you can't trust it. This is the evaluation harness I use to keep agents honest in production.
Logs tell you what happened. Traces tell you why. Here's how to build observability that actually works for multi-agent AI systems.
I replaced three databases with one. Here's why SurrealDB works for AI agent systems and what I gave up.
It's not about typing speed. It's about the infrastructure, the structure, and the discipline that let you move fast without breaking things.
Rust and TypeScript in one repo. Different languages, one source of truth. Here's how to make it work.
If an agent learns something wrong, you need to know why. Here's how we built a versioned, immutable memory system with a human-in-the-loop audit trail.
Most HITL implementations are an afterthought. Here's how to build human oversight that actually works in production AI systems.
When AI agents start making payments on behalf of humans, every traditional fraud signal breaks. Authorization, behavior, and identity all need rethinking.
Stop building in horizontal layers. Vertical slices — from database to UI in one shot — are how you actually ship with AI agents.
Your AI coding agent is only as good as the context you give it. Here's how I structure information so agents actually ship useful code.
Payment gateway migrations are the most dangerous period for fraud. Here's what attackers probe, what breaks, and how to survive the transition.
AI in production needs more than retry logic. Here's the engineering behind keeping AI systems safe, predictable, and affordable.
Every fraud rule you tighten kills real revenue. Here's how to think about false positives as a P&L problem, not a security dashboard number.
Most AI chat UIs are just message lists. Mine is a thin layer over a deterministic workflow engine. The UX is better for it.
95% of legitimate users don't act within 15 seconds of a deposit. That single insight changed how I think about fraud detection forever.
AI agents work better when your codebase has clear boundaries. A monorepo gives them that. Here's how.
Not everything needs multiple agents. But when it does, here are the patterns I've found useful.
AI demos are free. AI at scale is expensive. Here's how I think about building cost-predictable agent systems.
TypeScript was easier. Python was expected. I went with Rust anyway. Here's why.
Your current encryption will be breakable. Here's what you need to know and do about it — from someone who's built payment systems handling real money.
The mental model shift that changes how you build AI systems.
Most AI systems are goldfish. Here's how I think about memory for agents that need to learn and persist knowledge.
Everyone's building AI agents. Almost none of them work reliably. Here's what I've learned building production agent systems.
Let the AI figure it out is not a production strategy. Here's why separating control flow from reasoning matters.
I've built systems that scaled to millions of users and systems that collapsed at thousands. The difference is boring.
Every engineer complains about tech debt. Most of them are wrong about what to do about it.
What I actually do when taking over a new team or organization. Spoiler - it's mostly listening.
The most important skill in product and engineering leadership is saying no. Here's how to do it without being an asshole.
I've hired dozens of engineers. Here's what predicts success and what's just noise.
Your relationship with your boss determines more than your technical skills. Here's how to navigate it.
Every engineering leader faces this question constantly. Here's my framework for thinking about it.
Most 1:1s are status meetings. They should be so much more.
Most product strategies aren't strategies. They're wish lists. Here's the difference.
The code is the easy part. Getting alignment with humans is where it gets hard.
Your internal tools and processes are products. Treat them that way.
Culture isn't the poster on the wall. It's what happens when leadership isn't watching.
Most logging is useless noise. Here's how I think about logs that actually help when things break at 3am.
What I've learned leading engineering teams across 3 time zones — the systems that work and the mistakes I made along the way.
I built fraud detection systems for iGaming and payments. Here's what actually works — and what's just vendor marketing.
When to build configurable systems vs. hardcode it. Real examples of when I got this right, and when I over-engineered.
I've evaluated hundreds of tools for teams. Here's the framework I actually use — not the vendor's checklist.
Every project has risks. Here's how I identify them early and keep them from killing the product.
Ship fast or ship right? It's a false choice. Here's how I actually make the tradeoff.
Lean isn't just for factories. Here's how I apply it to software — and where it breaks down.
Measuring engineering productivity is tricky. Here's what to track, what to avoid, and how not to destroy morale in the process.
I've managed teams across 3+ time zones for years. Here's what actually works — and the mistakes I made learning.
How I manage releases from planning to post-deploy monitoring. No chaos, no 2am fires.
Most post-mortems are theater. Here's how I run them so they actually prevent the next incident.
Most product metrics are vanity. Here are the ones I actually track — and why.
I've walked into projects that were 6 months behind with no clear path forward. Here's how I turn them around.
I've written docs that saved projects and docs that nobody ever opened. Here's the difference.
Most project decisions are made with incomplete information. Here's how I think through risk, budget, and trade-offs.
The textbook version of product development is neat and linear. Reality is messier. Here's what it actually looks like.
I've seen personas that transformed product thinking. I've also seen personas that were pure fiction. Here's the difference.
Prioritization is hard. These frameworks help — if you don't overthink them.
