The robot barista is a useful metaphor for where AI coding tools are today. A robot arm operating an espresso machine is a compatibility layer for a world built around human hands. An AI coding assistant operating inside an IDE is a compatibility layer for a world built around human developers. Both are useful, but the bigger question is whether the long-term value comes from imitating the existing workflow or redesigning the workflow around what modern technology makes possible.

Uber recently capped employee AI spending at $1500 per month per coding tool after reportedly exhausting its AI budget in just four months. That raises a larger question for engineering leaders: How much AI spending actually makes economic sense? In this post, I propose a framework for evaluating AI budgets not as a technology decision, but as an engineering capacity investment competing directly with hiring, platform improvements, and other productivity initiatives.

Why are corporations suddenly investing so heavily in teaching workers how to use AI after decades of minimizing employee training? The official explanation is productivity and empowerment. The less discussed possibility is that companies are using AI-assisted workflows to systematically capture institutional knowledge and convert human expertise into machine-readable and machine-repeatable processes. In other words, employees may be helping train the systems that eventually replace them.

AI coding agents are incredibly good at generating code. What they’re much worse at is recognizing when the right solution is to delete code instead.
That creates a dangerous failure mode: systems that appear to “work” while quietly accumulating layers of accidental complexity.
The real bottleneck in software engineering is no longer code generation. It’s judgment.

AI can now write code, fix syntax, and autocomplete entire programs. But that was never the real point of learning computer science. The true value lies in developing judgment, abstraction, and the ability to model complex systems. As AI handles more of the mechanics, it reignites a deeper question: Is CS education training workers or cultivating thinkers? The answer determines whether computer science belongs in engineering or in the liberal arts.

Patching used to buy you time. That assumption is breaking. As AI accelerates vulnerability discovery and exploitation, the gap between “bug exists” and “bug is weaponized” is shrinking fast. This changes the role of patching and exposes a bigger problem: Most organizations aren’t built for what comes next.

AI has removed the bottleneck in writing code, but it hasn’t yet made running software that much safer. As attackers get faster and more automated, the real challenge isn’t building systems; rather, it’s defending them. Just because you can replace an “expensive” SaaS subscription with an in-house vibe-coded app doesn’t mean you should. This is why SaaS is just getting started, not fading away.

A single label on a web form might seem trivial until it sparks headlines and diplomatic tension. This post reminds you that you can tweak your browser while highlighting a serious point: interface text carries meaning, and contextual, localized design is increasingly critical. Along the way, we revisit the DIY spirit of the early web and explore why even small design choices deserve attention from engineering and product leaders.

AI has optimized code generation. It has not optimized code review. As teams adopt AI-assisted development, output is rising faster than human review capacity. This structural imbalance will have predictable consequences. In this post, I explore why verification debt may be the real risk of AI coding.

AI coding tools aren’t failing engineering teams, but bad takes on how to use them are. Some engineers are abdicating responsibility to AI and accumulating tech debt at record speed, while others resist the tools entirely and confuse inertia with rigor. Both sides miss how AI actually fits into professional software development. This post classifies the failure modes, and the path between them.

Headlines about the AI’s industry’s unsustainable costs miss the deeper shift happening in enterprise software. AI suddenly makes whole categories of messy, judgment-heavy enterprise workflows addressable by SaaS for the first time. That’s a massive, transformative expansion of what software can profitably do. In this post, I explain where the real money is going to be made.

AI and LLM chat completions make it tempting to treat a single API as a magic shortcut to everything. But behind the scenes, these “easy” integrations can be slow, unreliable, and opaque. In this post, I break down why relying on AI as your integration layer can backfire, and how understanding APIs and proper architecture makes LLMs genuinely powerful. Learn why real engineering still matters in the age of vibe coding and AI mashups.

AI agents promise autonomy, but they inherit a serious flaw: Hallucinations and blind spots that won’t be fixed by reasoning techniques and prompt engineering alone. But there’s good news: We’ve been dealing with reliability problems for decades in human and software systems. In this post, I introduce proven real-world workflows can make AI agents dramatically safer.

What happens when your AI coding assistant quietly inherits someone else’s politics? CrowdStrike’s analysis of DeepSeek shows how bias can slip into not just essays or articles, but into the code itself. That means security risks for developers, enterprises, and anyone building on top of these tools.

Enterprise AI pilots often shine in demos but fall flat in production. Why? Teams expect the LLM to clean up messy retrieval, and it can’t. In this post I call out the common anti-patterns, outline how to engineer retrieval properly, and share a playbook for RAG that actually works.

By now everyone’s heard the claim that 95% of enterprise GenAI projects “fail.” But most of those failures aren’t about the quality of the models. They’re about mismatched user expectations. We’ve spent 20 years training people to expect instant Google-style search results, and now we’re dropping LLMs into that paradigm. It’s no wonder users are frustrated.

Many developers assume the next big AI release will close the gap between flashy demos and production-ready systems. But what if that last 20% never arrives? In this post, I look at what stalled progress in GenAI means for building business systems, and how we can design for robustness instead of wishful thinking.

LLM coding assistants have made prototyping easier than ever, but they haven’t changed the fundamentals of software engineering. In this post, I explain why vibe-coded systems should almost never go directly to production, and what to do if your team is headed in that direction.

When AI agents are given broad control over critical systems, mistakes aren’t just possible — they’re inevitable. I explain why LLMs, as advanced as they seem, are fundamentally statistical guessers, not trustworthy decision-makers. This is a must-read for anyone considering AI-driven automation in production.

Prompting an LLM is the new coding, but we're still only reviewing the output. What if your team reviewed the prompts alongside the code? Let’s explore the idea of “code+prompt” review, and what it could mean for quality, security, and engineering culture.