Good Taste the Only Real Moat Left
by Raj Nandan
AI commoditizes competence, but judgment becomes scarce. The real edge isn't in output quality but in pairing taste with context and the conviction to build something meaningful.
A collection of blog posts I enjoyed reading and found worth sharing.
AI commoditizes competence, but judgment becomes scarce. The real edge isn't in output quality but in pairing taste with context and the conviction to build something meaningful.
AI systems behave in ways that defy intuition and resist simple categorization. Understanding their weirdness is essential for anyone building with or around them.
Your silence at work isn't protecting you. It's costing you. Ask for what you actually need.
Time investment shapes thought patterns, which compound into skill. Where you focus your hours is where your expertise emerges.
Technical debt isn't an engineering morale problem. It's a code problem. A quick audit reveals whether you're fighting the system or the people.
Leaders who pause to examine what worked and what didn't gain insight that keeps them from repeating mistakes and compounds their effectiveness.
Building reliable systems around AI agents requires intentional design patterns. Harness engineering treats the agent as a fallible component in a larger architecture.
A roadmap for the career arc beyond your first years in web development, from someone who's lived it.
Coding agents work when they combine three things well: tools, memory, and repository context. Understanding these components explains why some agents fail and others don't.
Code review catches bugs, but great review reduces comprehension debt. PRs should help teams understand the codebase faster, not just validate changes.
When a CTO is genuinely aligned with the business, the entire organization temperature shifts. Misalignment creates hidden friction that compounds across teams.
A relentless focus on velocity led to building more interesting, random, and useless scripts and tools than ever before. Sometimes the best learning comes from building things that don't need to exist.
React's use() hook reads promises and context at render time without the complexity of useEffect. The missing piece that finally makes async patterns feel native to component rendering.
A hands-on guide to making Claude Code part of your actual development workflow.
The .claude folder is where you configure your entire Claude Code experience. How CLAUDE.md, custom commands, skills, agents, and permissions work together.
When you need something from a defensive or hostile coworker, transaction-focused approaches backfire. The strategy requires reframing the relationship before the ask.
Knowing when to intervene as a manager is a skill distinct from knowing how. The difference between micromanagement and appropriate guidance lies in recognizing which moments actually require your involvement.
A reflection on the cost of constant acceleration and what happens when you deliberately choose to slow down.
Transforming into an AI-first company isn't about tools. It's about fundamentally rethinking how software gets built and how engineering teams organize around that change.
True rigor in modern systems often looks like apparent recklessness. The Phoenix Architecture challenges conventional wisdom about structure and control.
Behind the polished presentations and formal agendas lies a messier reality about how decisions actually get made in board meetings.
A decade-long journey of migrating an entire codebase to TypeScript reveals lessons about gradual modernization at scale.
Being right doesn't matter if nobody understands what you're saying. Learn the core gap between clarity and correctness.
AI tools are helping engineers write better tests at scale, tackling one of engineering's persistent blind spots.
The role of managers is evolving with AI, not disappearing. What changes and what stays the same.
Agentic patterns aren't about replacing engineers. They're about building systems that elevate code quality and developer productivity.
A practical technique for exposing hidden assumptions in your thinking by playing with timescales.
Why CLI-based patterns are winning over MCP for building AI agents and what it means for the tooling landscape.
A concrete cost comparison between CLI and MCP approaches reveals surprising economics for agent deployment.
One engineer rebuilt Next.js on Vite with AI assistance, achieving 4x faster builds, 57% smaller bundles, and Workers deployment in a week.
Why do we comply with directives we privately question? The crucial distinction between power through fear and authority through legitimacy.
Microservices unlocked backend autonomy, but applying the same pattern to frontends isn't always the solution. When micro frontends genuinely add value.
Beyond technical debt: a framework for understanding four types of system debt including technical, evolutionary, and cognitive dimensions.
A grounded take on what AI is actually changing for non-tech folks, cutting through the noise to explain real implications.
The Model Context Protocol is creating a common language between AI and apps, enabling a new category of integrations and possibilities.
LangGraph codifies complex workflow architectures as executable automations, giving structure to stateful AI reasoning.
Relying on LLMs for sensitive data redaction introduces hallucination risks where accuracy isn't optional. Deterministic approaches are essential.
What happens when you build production infrastructure using only AI agents writing code? A two-month experiment in agentic development constraints.
MCP UI extends the Model Context Protocol to let AI agents return interactive components instead of just text, making agent outputs more actionable.
Build fully functional agents using on-device models like Phi-4-mini in under 200 lines of code, bringing AI inference closer to users.
As AI coding agents evolve from tools to collaborators, our code organization and documentation must evolve with them. How to structure projects for agent-friendly codebases.
Understand the evolution from simple automation to intelligent agents: their architecture, capabilities, and why they represent a fundamental shift in how we build software.
Skip the experimentation phase with ready-to-use agent patterns and copy-paste code snippets designed to improve your LLM applications immediately.
Anthropic's battle-tested principles for building reliable, production-ready AI agents that actually work at scale.
Move beyond simple request-response loops to deep agents that maintain state, reason over extended periods, and handle genuinely complex multi-step workflows.
How agentic AI workers with Mastra.ai and MCP can automate e-commerce operations end-to-end, reducing manual overhead significantly.
Real lessons from integrating AI tools into daily development work: what worked, what didn't, and how adoption patterns are changing how senior engineers operate.
A deceptively simple framework for making hard decisions as an engineering leader by focusing on what matters most.
Career growth isn't always up. Discover the three key motivators that matter in a saturated job market and why your next strategic move might be staying put.
Performance gains matter in production. Practical optimizations to run Next.js faster in Kubernetes environments.
The SaaS model's greatest strength becomes a liability as AI commoditizes once-differentiated products. The race for profitability just got harder.
A resilience pattern that tests whether your system can survive the removal of its own components. Architecture thinking at its most practical.
A decade of management experience distilled into non-obvious advice that changes how you think about leading engineers.
When product and go-to-market strategies drift, founders lose leverage. How to align both around metrics that actually predict customer success.
Neurodiversity isn't just about accommodation. It's about understanding how different thinking styles create friction in teams and how to navigate it.
Scale frontend architecture without scaling complexity. Module Federation enables independent teams to ship in parallel without coordination overhead.
Five critical questions are reshaping how we build software. Competing scenarios for each and what they mean for your choices today.
Manager instinct often says fix everything at once, but the easy way forward is paradoxically harder. Tackle bottlenecks sequentially to avoid chaos.
Explores the distinct challenges and opportunities of leading engineering teams across distributed locations, moving beyond one-size-fits-all remote work policies.
Document templates and structural tools that help scaling engineering organizations maintain clarity and alignment as teams grow.
The playbook for engineering management has shifted in the post-ZIRP era, requiring managers to balance efficiency with the realities of constrained resources.
Distilled wisdom on code quality, career progression, and the interpersonal dimensions of engineering drawn from nearly a decade and a half at scale.
Challenges the assumption that modern management practices are universally correct, arguing context and organizational needs matter more than dogma.
Claude can now discover and dynamically execute tools in real-time, enabling AI agents to take actions directly in external systems without pre-integration.
Technical strategies and infrastructure patterns for handling peak traffic during Black Friday and Cyber Monday at scale.
A grounded, practical approach to working with AI coding agents that cuts through hype and focuses on what actually works.
Lessons from building a metrics tool using subagents to split work in parallel, demonstrating concrete patterns for AI-accelerated development workflows.
Effective organizations communicate fluidly across org chart boundaries rather than rigidly following reporting lines, accelerating decision-making.
Writing code is only one part of effective software engineering. LLMs excel at code generation but lack the architectural thinking and quality assurance that define professional development.
What the data really shows about AI coding tools in 2025. Most effective as assistants handling boilerplate, not as replacements for human judgment.
LLMs can be powerful thinking partners for engineering leaders. Using them creatively for brainstorming and decision analysis sharpens your leadership.
Teams perform best when individual autonomy aligns with shared goals. Give engineers clear direction and freedom to solve problems their way.
Effective AI prompting requires the same information architecture rigor we apply to software. Structure context intentionally for consistently better outputs.
Strong engineering managers protect their teams by absorbing difficult decisions. Taking ownership means sometimes being the one who makes unpopular calls.
Incremental infrastructure modernization avoids the risk of full rewrites. Airbnb's approach to rolling out new React features while maintaining stability.
Engineering challenges shift as products mature. Startup hustle, scaleup organization, and enterprise reliability each demand different strategies.
Effective leadership isn't about having all answers. Create psychological safety where learning is expected, failure is normalized, and your team drives innovation.
Continuous incremental shipping beats ambitious batches. Regular releases reduce risk, gather feedback faster, and keep momentum strong.
Cookies are ubiquitous client-side state flowing across every request, making them a critical security surface. How Slack detects and mitigates compromised session cookies.
Design docs are a cornerstone of Google's engineering culture, serving as the mechanism for aligning teams and capturing architectural reasoning before code is written.
AI coding assistants can accelerate delivery but risk eroding the fundamentals that make engineers effective. Strategies to maintain depth while leveraging AI.
Booking.com doubled their team's delivery performance in a year by systematically measuring and improving the four DORA metrics.
Slack open-sourced their AI-driven migration tool that automatically converts Enzyme tests to React Testing Library, balancing modernization with preservation of testing intent.
As systems scale, platforms must evolve into managed runtimes that abstract complexity and cognitive load. Moving from passive infrastructure to active runtime enablers.
Navigating a startup culture that rejects management infrastructure. When flat structures work and when they create scaling friction.
Rather than top-down reorganization, solve staffing problems from the inside out using concentric circles to progressively expand and restructure teams.
Technical debt is a strategic tool for CTOs, not a burden to minimize. When managed intentionally as a financing mechanism, it accelerates delivery without sacrificing velocity.
Great corporate engineering blogs share specific technical insights rather than abstract principles. They succeed by writing about real problems and trade-offs.
What looks like a management mistake often works surprisingly well. Larson challenges three conventional anti-patterns that actually drive results at high-performing companies.
Apply wilderness ethics to engineering leadership: leave systems cleaner than you found them, minimize your footprint, and respect the team's capacity.
Skip the metrics theater. How to design a minimal, effective process that uses the right metrics to drive real improvements in engineering productivity.
Knowledge silos compound every other technical debt. Practical strategies to identify and break them down before they paralyze your team.
A mature design system isn't a library, it's an ecosystem. How components, tokens, and governance scale across complex organizations.
Design systems should move slower than the products they serve, yet still enable rapid iteration. How deliberate pace prevents bottlenecks.
Agents reason better with structured context. How to engineer context quality so agents understand code intent and constraints.
Google's testing playbook: test size taxonomy, test selection strategies, and how to scale CI/CD without creating brittleness or slow feedback loops.
Move computation from runtime to build time. A Vite plugin that evaluates TypeScript expressions at compile time for smaller bundles and better performance.