Skip to main content

Tag · 39 essays

AI engineering

Writing tagged "AI engineering".

← All writing

Building MCP Profile Hub part 2, one MCP server is the wrong abstraction

This article argues that a single, monolithic MCP server per platform is the wrong abstraction, especially for complex systems like Contentstack. Instead, it introduces managed profiles as the right unit of configuration, aligned to jobs, teams, or access boundaries rather than product catalogs. Each managed profile bundles a curated set of tools, Automations, and agents, enriched with account context, while still respecting individual user identities and permissions. Profiles can only narrow what a user can do, never expand their underlying platform permissions. This makes configurations easier to reason about, review, audit, and replicate across environments, and offers a scalable pattern for enterprise platforms with many roles and capabilities.

  • Composable architecture
  • AI engineering
  • API design
  • Frontend

Building MCP Profile Hub, part 1: Stop making the agent ask

Introducing MCP Profile Hub. I explain why enriching tool definitions with tenant-specific context dramatically improves agent performance. Instead of exposing generic CMS tools that force models to discover content types, environments, locales, and branches through multiple lookup calls, Profile Hub injects real account data directly into JSON Schemas as enums, defaults, and descriptions. This reduces tool calls, latency, and reasoning tokens while avoiding misleading examples and invalid defaults. The piece also covers the production engineering behind enrichment, how Automations and Agent OS agents are exposed as high-level deterministic tools, and why reusable HTTP-based tool definitions let teams run their own MCP runtimes. The core takeaway is that fewer, richer, context-aware tools beat large generic catalogs for real-world agent workflows.

  • Composable architecture
  • AI engineering
  • API design
  • Frontend

Claude Desktop MCP lifecycle is broken

Claude Desktop currently launches duplicate local MCP stdio servers for a single configuration, causing two independent OAuth flows, extra browser tabs, and unnecessary resource usage. The bug is masked once credentials are cached, so it silently persists in production while still spawning two processes every time. This is not an mcp-remote or external service issue but a host-level lifecycle problem, likely caused by overlapping legacy and new MCP managers and poor observability for one of the processes. Workarounds like pre-authenticating with mcp-remote mitigate UX pain but do not fix the duplication. The article argues that open-source tools should not shoulder complex coordination logic just to survive a major desktop app’s sloppy process management.

  • Composable architecture
  • AI engineering
  • Performance
  • Cloud & infra

Buy the plumbing, vibe the rest

AI makes it tempting to cancel SaaS tools and prompt your own internal platforms into existence, but that often creates brittle systems that are “a mile wide and an inch deep.” Performance, security, and edge cases quickly become serious problems, and suddenly your team is doing database administration and security engineering instead of solving business problems. A better pattern is to buy robust, headless infrastructure for the hard, invisible parts (content, data, security, scaling) and then use AI to build bespoke experiences on top. With a solid SDK and stable backend services, AI tools like Claude can safely orchestrate UI and workflows instead of guessing at architecture. Pay for the plumbing, and vibe on the interface layer where your differentiation really lives.

  • Composable architecture
  • AI engineering
  • Frontend
  • Developer experience

The Doer Economy - we are killing the translator class

This article argues that AI is collapsing the distance between vision and execution, ushering in a Doer Economy where the primary winners are those who can both imagine and build. The traditional corporate stack of translators (product managers, marketers, and multiple layers of management) is shrinking because executional tasks are increasingly handled by AI. Founders and CEOs are moving closer to product, validating ideas directly with AI-generated scaffolds and modern SaaS primitives. For individuals, the value has shifted from narrow, ticket-driven skills to end-to-end ownership, product thinking, and understanding users. The future belongs to people who ship, iterate quickly, and leverage AI and SaaS platforms to focus on business logic and user experience, rather than those who only manage the builders.

  • Composable architecture
  • AI engineering
  • API design
  • Frontend

Ten AI security problems hiding in plain text

This article argues that AI security risks extend far beyond model jailbreaks and prompt engineering, into every piece of text an AI can read. Natural language now behaves like soft code, where logs, documentation, commit messages, wikis, support tickets, web pages, PDFs, and search results can all carry hidden instructions for agents. The author walks through ten concrete scenarios where ordinary text fields become attack surfaces, often with delayed or indirect activation through internal tools and multi agent pipelines. The core message is that information and instruction have blurred, and any text accessible to AI must be treated as part of the security model. Teams need to rethink access, editing rights, retrieval, and agent capabilities accordingly.

  • Composable architecture
  • AI engineering
  • Cloud & infra
  • Frontend

The biggest risk to AI is the enterprise org chart

This article argues that the real risk of corporate AI is not rogue superintelligence but how large organizations deploy it, usually in service of cost-cutting rather than creating new value. Big enterprises buy AI like office furniture, wrapped in committees, procurement, and risk matrices, so it ends up optimizing ticket deflection and headcount instead of enabling innovation. The real bottleneck is bureaucracy, not intelligence. In contrast, a roughly 500-person company has enough depth to build serious systems but short enough communication paths that the person with the problem can help build the solution. AI lets domain experts prototype directly, shortening the loop between friction and fix. The key is governance that enables safe experimentation instead of vetoing it, using AI to expand reach rather than just reduce costs.

  • Composable architecture
  • AI engineering
  • Frontend
  • Product strategy

We are thinking too small

AI coding agents are not a threat to developer jobs, they are a fundamental shift in the economics of software creation. Just as the cloud removed the risk and capital cost of infrastructure, AI is removing the cost of writing and refactoring code. This kills the old moats that protected horizontal enterprise platforms and makes rebuilding wide, deeply integrated stacks viable. Instead of spending years stitching together narrow SaaS tools and APIs, teams can let agents generate bespoke services quickly and cheaply. The real risk is using AI only to speed up legacy glue work. Developers who win will treat the cost of reinventing the wheel as effectively zero and pursue much larger, previously impossible product ideas.

  • Composable architecture
  • AI engineering
  • Cloud & infra
  • Frontend

Cursor's moat

The interesting story about Cursor is not which base model it uses, but how deeply it sits inside real software development workflows. Unlike model labs trained only on finished code artifacts, Cursor’s IDE sees every attempt, failure, context switch, and accepted edit as developers ship real software. That environment, with multiple models competing on the same tasks, produces rich feedback signals that are closer to “which path got the work done” than traditional preference data. The piece generalizes this idea beyond coding tools, suggesting that any serious AI product should focus on generating observable traces of work, outcomes, and corrections, and treat the product workflow itself as part of the training system and long-term moat.

  • Composable architecture
  • AI engineering
  • Frontend
  • DevRel

The tool catalog is the product

We exposed Contentstack MCP tool definitions through a server endpoint as JSON. That sounds small, but it changes the product shape. The hosted MCP server becomes one official implementation of a reusable tool catalog, while developers can build their own MCPs with their own auth, hosting, filtering, and governance. This is what AI-first developer tooling should feel like: polished defaults on top of portable primitives.

  • AI engineering
  • API design
  • Developer experience

AI will not live in one place, but trust has to

Enterprise AI is spreading into every tool where work happens, from IDE agents to browser assistants, but governance, spend control, and brand safety are lagging behind. This article explains a two-layer architecture for solving that tension. Off-platform AI, powered by APIs, MCP, and agent skills, acts as the reach layer that lets developers and teams experiment, prototype, and orchestrate across systems from within their preferred tools. On-platform AI, delivered through Agent OS, Polaris, and AI Credits, is the trust layer that handles permissions, spend visibility, brand context, review workflows, and auditability. Rather than choosing between open access and tight governance, enterprises should use both layers together so external AI gathers context while governed on-platform capabilities execute business-critical work safely.

  • Composable architecture
  • AI engineering
  • API design
  • Content ops

The case for boring setups

Most developers overconfigure their machines and pay for it in ways they don't notice. Every custom alias, every remapped key, every hand-rolled config file is a small tax on your ability to work anywhere other than your own laptop. The same pattern is repeating right now with AI tooling, dozens of MCP servers and stacked skill files that look like leverage and behave like drag. After getting stranded by my own setups more times than I'd like to admit, I've come around to a quieter belief: portability is a skill, and defaults are how you practice it.

  • Composable architecture
  • AI engineering
  • Cloud & infra
  • Frontend

I will not log into your vibe coded app

Vibe coding has made it trivially easy to spin up apps that collect user data, handle logins, and store sensitive information. The problem is that most people building these apps have no idea how authentication, database security, or data protection actually work. Defaults on services like Supabase and Firebase are dangerously permissive, GDPR obligations are being ignored entirely, and users are handing credentials to apps built by people who have never heard of row level security. My personal rule now is simple. If it looks vibe coded and asks for username and password, I walk away.

  • Composable architecture
  • AI engineering
  • Cloud & infra
  • Frontend

We moved the difficulty. We didn't make it disappear.

In 2013 I built the Need for Speed Rivals launch site from scratch in five weeks - custom router, custom state, custom tweening engine, 35 languages, no framework worth mentioning. I rebuilt it recently for my Vue.js Amsterdam 2026 talk. The contrast broke my brain in the best way, and it clarified something I've been trying to articulate about AI, abstraction, and what "craft" actually means now.

  • Composable architecture
  • AI engineering
  • Frontend
  • Craft

Intuition and the real cost of research

This article explores how AI changes the balance between research-heavy processes and intuition-driven building, especially in product and technical work. The author reflects on a career of moving faster than surrounding teams, where strong intuition (really compressed experience from shipping many similar things) often clashed with expectations for lengthy research and documentation. As AI makes implementation and iteration dramatically cheaper and faster, the true bottleneck shifts from building to deciding what is worth building. Research still matters for those without established mental models, and for environments where stakeholders need evidence and paper trails. But when iteration costs hours instead of weeks, over-indexing on analysis can become the real drag. The piece argues that, in an AI-enabled world, experienced intuition is not anti-process; for the right people and problems, it is the process.

  • Composable architecture
  • AI engineering
  • Frontend
  • Product strategy

TDD finally makes sense

AI coding tools have removed the old excuse that test driven development is too slow or too costly. When AI can generate both implementation and test scaffolding in minutes, the time cost of writing tests first collapses, turning TDD into an obvious quality and productivity win. The real risk now is vibe coding, where developers ship AI generated code that looks fine but crumbles under real edge cases. By using AI for planning, then encoding that thinking as tests and letting the AI implement against them, teams get faster feedback, more reliable code, and fewer hotfixes. In an AI assisted world, the competitive advantage shifts to defining behavior and edge cases up front, and TDD becomes the discipline that makes that thinking explicit.

  • Composable architecture
  • AI engineering
  • Frontend
  • Product strategy

When Output Is Cheap, Taste Is Everything

This article explores how AI has radically reduced the cost of producing things, creating an intoxicating sense of limitless output for ambitious people. But when building becomes almost frictionless, the real bottleneck shifts from implementation to judgment. The author argues that taste (the ability to choose what is worth building) and genuine rest become the true sources of leverage. AI is an exceptional how engine, but deciding what and why remains a deeply human responsibility. Without rest, our judgment degrades, and we risk building more but meaning less. The piece encourages pairing curiosity and experimentation with discipline, restraint, and strategic downtime.

  • Composable architecture
  • AI engineering
  • Product strategy
  • Career

The pragmatic guide to coding with AI agents

AI agents are extremely capable coding assistants, but they are not magical autonomous engineers. Treat them like very fast junior developers who need clear scope, clean environments, and strong guardrails. Avoid context gluttony by limiting inputs to only the files and details needed for the task, and rely on search instead of dumping entire repositories. Skip over engineered MCP setups and excessive plugins in favor of simple, well understood tools. Fix your project environment so builds and checks run cleanly from the root. Use planning steps, a project specific “gotchas” file, tests as guardrails, and tightly scoped tasks to keep agents effective, predictable, and safe in real-world production work.

  • AI engineering
  • Frontend

MCP fragmentation, context efficiency, and the rise of curated skills

The Model Context Protocol (MCP) was supposed to be a universal way to connect AI models to tools, but in practice it is fragmenting fast across vendors and implementations. Tool catalogs are extremely context-hungry, making naive MCP setups expensive, slow, and unreliable, especially with cheaper models. Developers are compensating with application-layer tricks like curated tool subsets, OAuth-based selection, Claude Skills style abstractions, and wrapping deterministic automation platforms such as Contentstack Automate. These patterns improve cost, reliability, and debuggability but highlight protocol-level gaps in context efficiency, determinism, and interoperability. The ecosystem is replaying past standards wars, and no clear winner is visible yet. The pragmatic move is to design flexible systems that can adapt when consolidation and better standards eventually emerge.

  • Composable architecture
  • AI engineering
  • API design
  • Performance

AI integrations expose platforms without headless DNA

AI exposes which platforms were truly built API first and which ones only marketed it. As brands move into AI native workflows, the only viable path is a system that treats agents, events, and automation as composable building blocks. Contentstack's agentOS shows what happens when you start with API first DNA instead of bolting AI onto a monolithic core. This piece explains why AI native composability is the next logical layer of MACH and why brands should judge vendors by the architecture of their agents, not the slideware that surrounds them.

  • Composable architecture
  • AI engineering
  • CMS
  • API design

The MACH monolith in 2026

The 2022 diagnosis was right. Composable architectures need orchestration or they collapse. But the form factor was wrong. Teams rejected standalone orchestration layers as too heavy, another vendor, contract, and critical path. The 2026 reality is platforms that integrate orchestration directly, staying API-first and modular while providing built-in coordination. The shift isn't about more tools, but smarter platforms that reduce complexity fatigue without losing flexibility.

  • Composable architecture
  • AI engineering
  • CMS
  • API design

It's time to think of LLMs as having abilities, not protocols

TL;DR Don't over-engineer standards around protocols. Instead, treat your large-language-model as a toolbox of abilities (like search, translate, query, generate) that you plug into your system. By thinking of LLMs as modular and composable abilities rather than monolithic protocols, AI becomes accessible, practical and aligned with how engineering and product teams already build.

  • Composable architecture
  • AI engineering
  • CMS
  • API design