
A few weeks ago I was at an event with a very engaging keynote. There were a couple hundred people in the room, and partway through, the speaker asked for a volunteer: if you could have any software feature you wanted, what would it be? He typed the answer straight into a Claude prompt, set the agent to work, and carried on with his talk. At the end he showed us what had been built in the meantime — an interactive dashboard running on synthetic data, full of numbers and dials.
For those of us who do this every day, it was a neat way to show what AI agents can do, in terms almost anyone in the room could relate to. For most of the audience, it was something close to a magic trick. Give it a few months, a year at most, and this kind of demo will be something we take for granted, because by then the agents will be doing something we can’t yet picture.
That moment says a lot about the world we now live in. If you can build a convincing prototype in the time it takes to deliver a keynote, what does that say about building the software your company runs on? It is a dramatic shift for the whole industry, and for all the talk about it, I don’t think its implications are fully understood yet. The surveys are starting to catch up. In McKinsey’s State of AI survey published this August, 32 percent of respondents said their organizations had decided against buying at least one software product or feature because they could build it internally with agentic coding tools; among the companies McKinsey counts as AI high performers, it was nearly half. Retool — which, to be fair, sells tools for building exactly this kind of software — asked 817 people who build internal tools, its own customers among them, and found that 35 percent had already replaced at least one SaaS product with something custom-built.
I suspect it changes the arithmetic of starting a company. Building the product used to be the expensive part, and the code itself was something of a moat; once a working product becomes the cheap part, the scarce and valuable thing is getting it in front of the right customers.
Closer to home, I meet a lot of owners and executives of small and mid-size businesses, and lately a surprising number of them are building their own software, or at least trying to. Several are building their own CRM. When I ask why, the answers rhyme: the off-the-shelf product either lacked the features they needed or kept them behind an expensive premium tier, while arriving packed with functions they never use but still pay for, and click past, every day.
An off-the-shelf CRM, or any enterprise software for that matter, is designed around a set of features meant to satisfy perhaps 80 percent of its customers, and even with all its flexibility, it cannot accommodate every nuance of how a particular company does business. The software isn’t wrong; it was simply written for someone a lot like you, but not quite you. In the end the tool’s gravity wins: you add required fields, mandate the stages, and your people quietly adapt their instincts to the machine.
So a while ago I built a simple CRM for our firm. In addition to pipeline stages, it organizes contacts into connectors and communities, and tracks how many valuable leads each connector and community has introduced us to. When I want a new feature, I describe it to an AI agent in plain English, review what it changed, and keep going. We took the same path with our Knowledge Engine, which follows the way our research and decisions flow rather than the way a vendor imagined they might.
The most critical part was never writing the code; it was understanding what we were actually looking for — because everyone manages relationships a little differently, and the way an executive keeps in touch with a network is deeply personal, shaped by habit, temperament and the kind of work they do.
My impression is that this is why personal CRMs, for all the clever products launched over the years, have remained a niche, while company CRM grew into what one analyst firm puts at an $83 billion market. One personal-CRM maker put the problem well this summer: relationships “don’t have stages and close dates so much as rhythms, history, and context.” For many of us, the closest thing to a personal CRM is LinkedIn — superb at remembering whom we know, and of very little help in remembering the very context of our relationships.
Which brings me to the real shift. For four decades, adopting software has mostly meant adapting people to technology. Building your own tools with AI holds out the promise of the reverse: adapting technology to people. In an earlier essay, I asked whether we must settle for generic interfaces that force human beings to bend to the machine; the same question now applies to whole applications. Each of us can build a personal CRM that fits the way we actually keep in touch — and founders who could never have justified a custom build can now shape tools and automation around the natural workflow of their own unique business, the way they always envisioned it.
So, given how easy it has become to build your own software with Claude Code, Codex, Gemini or Grok, should you still buy off-the-shelf at all? Or, to put the question more usefully: when is scrappy good enough? Scrappy is great for testing new ideas inside a sandbox, where a bad day costs nothing but your own time. The bar rises the moment people start depending on the tool — a team that can’t do its job without it, or customers who see what it produces — because that is when maintenance, security, data privacy and stability become the critical things to get right, and someone has to own them.
Maintenance first: an AI agent can make most of the changes you ask for, but somebody still has to ask, check the result and notice when something has stopped working without telling anyone. Security: when Veracode had more than 100 language models complete 80 curated coding tasks last year, 45 percent of the results contained vulnerabilities from the OWASP Top 10, the standard list of the most critical web-application risks. Data privacy: who makes sure customer records are encrypted, access is segregated and sensitive data never wanders into someone’s training pipeline? Stability: what happens when the tool breaks at seven in the morning on the day of a board meeting?
Two more are easy to miss. Dependencies: a tool that has to keep pace with fast-changing third-party services, social networks being the classic case, can quickly become too cumbersome to maintain at home, at least for now. And ownership: who fixes it when the person who built it goes on vacation, or leaves? Retool found that 60 percent of builders had created something outside IT’s oversight in the past year — wonderful for speed, less wonderful for whoever inherits it.
When you pay for a SaaS subscription, you are rarely paying for elegant code. You are paying for a shield: someone else keeps the software patched, secure and running, even though your data, and who gets to see it, remain your responsibility. That shield is the most compelling reason to buy off-the-shelf software today. But does it have to come bundled with the product?
Software has solved a version of this before. Decades ago the industry moved the plumbing between systems into its own layer, middleware, so that every application didn’t have to carry it alone. Small businesses have long hired managed service providers to keep their networks and laptops running. Can we imagine a not-too-distant future where maintenance, security and privacy for software you built yourself are bought the same way, as a service, separate from the product? The first signs are already visible: agencies now advertise hosting, security reviews and ongoing maintenance for apps built with tools like Lovable, Replit and Cursor. What I would like to see next is the middleware version — an independent layer you could plug a home-built tool into, which takes the upkeep off your hands without asking you to buy a bloated suite along with it, while you still decide what the tool does and who sees what. If that market emerges, the strongest reason to buy off-the-shelf loses much of its force.
Until then, things are changing quickly, but here is where I would draw the line today. Simple tools that don’t need enterprise-grade guarantees can absolutely be built, and there is no excuse not to build them: the tracker your team actually wants, a dashboard for your customers, a simple reporting tool. Just know exactly where the data comes from, who can see it, and who fixes the tool when it breaks. More complex solutions — anything that becomes a commercial product, touches the core systems holding your business records, handles sensitive data or depends on more outside services than your team can keep up with — still call for buying, or for professionals. The build-versus-buy question has never really been about technology; it has always been about risk. We bought packaged software because custom software was an expensive gamble, and an 80 percent fit was a fair price for handing most of that risk to someone else. As the cost of building a working tool keeps falling, that compromise starts to feel less like safety and more like an artificial limit on how your people work.
If you could be certain the plumbing and privacy would run quietly behind the scenes, what tool would you build for your team tomorrow morning — and why are you still asking them to adapt to someone else’s? Besides, when you build software yourself, you finally get to decide which useless buttons not to include — and when something breaks, you won’t spend forty-five minutes explaining to a vendor’s chatbot why your business doesn’t fit their drop-down menu.



Agree it was always about risk. Building a dashboard live on stage is the easy part. The question I'd want a CFO asking is who keeps it running in year two, after the person who built it moves on. For a lot of companies that answer still points to buying.