{"slug": "the-primitive-is-the-product", "title": "The Primitive Is the Product", "summary": "Software companies must shift from feature-centric design to primitive-first abstractions as AI agents, not humans, become the primary users. HashiCorp's philosophy of collapsing complexity into composable primitives provides a blueprint for building products that agents can reliably invoke via APIs, treating every software company as a developer tools company.", "body_md": "# The primitive is the product\n\nFor as long as software has existed it’s been principally designed for human consumption.\n\nUsers clicked buttons, navigated workflows, learned new interfaces. They spent years developing muscle memory for products like Excel, Photoshop, Salesforce, Github, Jira, etc.\n\nAnd so emerged a simple logic governing software economics: own more workflows, capture more value.\n\nIn this era, features became the currency of software. Every new feature expanded the product's surface area, increased switching costs, and pulled users deeper into the platform.\n\nAI completely subverts this logic.\n\nThe most important characteristic of the AI platform shift has less to do with the new technological foundation (e.g. the model) we’re building on, and much more to do with the new type of user (e.g. the agent) we’ve introduced.\n\nAgents, which are already consuming a rapidly expanding share of software, have a completely different interaction model than humans. They don’t *navigate* software so much as they *intuit* and *compose it*. Because the native language of the agent is code, they don’t see your GUI, but they do consume your API spec.\n\nMore plainly, agents could care less about dashboards, buttons, settings pages, etc. They care purely about capabilities, e.g. the inputs, outputs, and explicit constraints of your program and whether those can be invoked and chained reliably.\n\nMy friend David Crawshaw, founder of exe.dev (and before that Tailscale), put it best: “the best product for an agent is just the best product for a developer.” It's no surprise that agents become dramatically more reliable when a prompt simply begins with ssh!\n\nSuddenly, every software company needs to start thinking like a developer tools company.\n\n**The Tao of HashiCorp**\n\nLong before LLMs, HashiCorp figured out something many software companies missed.\n\nUsers don't want features, they want outcomes. Thus, the job of a product is to collapse complexity into the smallest yet most powerful abstraction that enables those outcomes.\n\nThis philosophy became known as the [Tao of HashiCorp](https://www.hashicorp.com/en/tao-of-hashicorp).\n\nHashiCorp understood that the hardest problem in software is not implementation, rather it's deciding where to draw these lines of abstraction. Where should the system be opinionated vs. where should it remain extensible? Where should complexity be hidden vs. where should it be exposed?\n\nThe magic of HashiCorp was never in building the most feature-complete products which provisioned infrastructure or managed secrets. Their genius was in deeply understanding the practitioner and their workflows and identifying the right abstraction for the job to be done.\n\nTake Terraform. Rather than encoding the logic for every infra management workflow into the product itself, it exposed a lower-level building block: a declarative graph of resources and their dependencies. That primitive was just opinionated enough to get developers productive immediately, yet extensible enough that thousands of providers, modules, and internal platforms emerged around it. The differentiator was in composability.\n\nHashiCorp recognized that technology can be but an implementation detail. What mattered was finding the abstraction that cleanly captures the underlying workflow while hiding unnecessary complexity. The power was not in the product but in the primitive!\n\nAnd once you get the primitive right, it becomes the building block that everyone else standardizes around. The abstraction ultimately becomes the interface, the interface becomes the ecosystem, and the ecosystem becomes your competitive advantage.\n\n**Thinking like a dev tools company: the primitive-first mindset**\n\nThe philosophy outlined in the Tao of HashiCorp provides a blueprint that every software company will need to internalize in the age of agents. But doing so requires a radical departure from how most products have been designed since the very birth of the software industry.\n\nFirst and foremost, teams need to stop thinking in terms of features and prescriptive workflows and start thinking in terms of abstractions and capabilities.\n\nFeatures are a liability for agents. Every feature expands the decision space an agent must reason about. More features mean more edge cases, more ambiguity, and more failure modes. At best, this translates into higher token spend, and at worst, into busted agent behavior.\n\nAgents naturally gravitate toward the smallest stable abstraction. So, in an agent-first world, the most important question facing product teams is not what features and why, but instead **how do I design the right primitive{{primitive-fn-1}}? **\n\nBuilding great developer tools (e.g. primitives) has always been an exercise in exquisite taste and deep domain expertise because it requires balancing a set of competing, and often contradictory, forces: namely the tension between expressivity and simplicity.\n\nThe more opinionated the abstraction, the more delightful the experience can become. But every opinion embeds assumptions which constrain what can be built on top or changed down below. So what you gain in usability, you often lose in flexibility.\n\nThe canonical example is EC2 vs. Heroku. EC2 exposed a low-level primitive: the virtual machine. You could install anything, run anything, and compose it however you like. It's powerful precisely because it's minimally opinionated.\n\nHeroku, by contrast, provided a complete deployment platform (on top of EC2). The developer experience is magical: git push and your application is live. Simplicity! But that elegance comes from making a series of opinionated decisions on behalf of the user. As a result, you sacrifice flexibility and control for that ease of use.\n\nThe best-designed primitives feel powerful but deceptively simple, if not outright boring. This is not because the problem itself is simple, but because complexity has been compressed into the abstraction in a thoughtful way.\n\nConsider S3, one of the most important infrastructure products of the last 20 years. S3 exposes an astonishingly small surface area with three core commands: Put. Get. List. Everything emerges around those operations.\n\nThe value, ultimately, isn’t in feature depth, but in the quality of abstraction.\n\nAnd so, the foundational philosophy of product development becomes flipped on its head. The old question was: \"What feature should we build next?\" The new question becomes: \"What capability should others build upon?\"\n\n**Claude vs Pi**\n\nMy favorite current example of the products vs. primitives debate is Claude and Codex vs Pi.\n\nI've fallen in love with [Pi](https://pi.dev/), a coding tool created by [Mario Zechner](https://mariozechner.at/) that bills itself as a \"minimal agent harness.\" At first glance, Pi appears less sophisticated than products like Claude or Codex, but that’s precisely the point.\n\nClaude and Codex are vertically integrated *products* that bundle planning, execution, context management, tool calling, workflow orchestration, and the underlying model into a single unified experience. Anthropic and OpenAI seek to own the entire agentic coding workflow, soup to nuts.\n\nPi takes the opposite approach: it’s deliberately narrow. Pi is opinionated about execution, but leaves it to the developer (or agent) to decide the particulars of their desired workflow. Rather than shipping a complete coding product, it exposes a simple, pluggable coding agent harness…a set of primitives, if you will.\n\nIf you’ve read this far, you already know the tradeoff inherent in this design. Vertically integrated products can move faster initially because they own the entire workflow and offer users the proverbial easy button to get started. Simplicity!\n\nPrimitives, on the other, are slower to appreciate because they require users to be thoughtful about their workflow up front and then assemble the pieces themselves. You’re likely not getting that “magic moment” for a user within minutes of them trying the product.\n\nBut primitives possess several unique advantages that become more obvious over time…like a fine wine.\n\nFirst, they are inherently more malleable and adaptable. Claude and Codex users are tied to the opinions, workflows, and, critically, the models chosen by their creators. Pi, by contrast, can evolve with the ecosystem. As new models, tools, and workflows emerge, they can be incorporated without waiting for the platform owner to bless them.\n\nSecond, primitives compound. Every workflow built on top of Pi increases its value, as each new integration expands its ecosystem and every new use case further strengthens the abstraction.\n\nThis is a pattern we've seen repeatedly throughout the history of infrastructure. The most valuable layer is often not the application itself but the primitives the application depends on (see our earlier EC2 vs. Heroku example).\n\nProducts may come and go, but primitives become standards.\n\n**Extensibility compounds**\n\nIt’s worth dwelling more on the concept of compounding extensibility and the role of the ecosystem. Many software companies struggle with this idea because it runs counter to decades of product strategy.\n\nHistorically, sharing the ecosystem was dangerous because it gave life to competitors building on your API and potentially cannibalizing features you yourself could monetize. Platforms frequently fenced themselves off once third parties became “too successful.” The incentive was always to absorb the value back into the product, and in a world where humans were the primary consumers of software, this made sense. Look no further than all of the license changes over the past decade from major OSS infra providers as evidence.\n\nBut agents fundamentally upend this equation…again!\n\nAn agent doesn't care whether functionality comes from one vendor or fifty. It only cares whether the capability exists, and whether it’s meaningfully better than alternatives.\n\nEvery third-party integration becomes another tool the agent can leverage. Every extension increases the utility of the underlying primitive. The value of having a community that works on these things, that complements the work your team is doing, can’t be understated.\n\nAll of this means the winning products and strategies going forward will look very different from those of the SaaS era. The most valuable companies will *allow* every use case to emerge instead of trying to solve each one themselves.\n\nWhereas the old moat was defined by feature breadth, workflow ownership, and data gravity, the emerging moat may be something much simpler: the elegance of the abstraction.", "url": "https://wpnews.pro/news/the-primitive-is-the-product", "canonical_source": "https://www.amplifypartners.com/blog-posts/the-primitive-is-the-product", "published_at": "2026-07-01 08:49:36+00:00", "updated_at": "2026-07-01 09:21:16.184320+00:00", "lang": "en", "topics": ["artificial-intelligence", "ai-agents", "developer-tools", "ai-infrastructure", "ai-products"], "entities": ["HashiCorp", "Terraform", "David Crawshaw", "exe.dev", "Tailscale", "Salesforce", "GitHub", "Jira"], "alternates": {"html": "https://wpnews.pro/news/the-primitive-is-the-product", "markdown": "https://wpnews.pro/news/the-primitive-is-the-product.md", "text": "https://wpnews.pro/news/the-primitive-is-the-product.txt", "jsonld": "https://wpnews.pro/news/the-primitive-is-the-product.jsonld"}}