Let’s be honest, you’ve been in this meeting. You're sitting in a stuffy conference room, watching a slick vendor demo. The software looks great, the price is right, and everyone around you is nodding. You’re just about ready to sign on the dotted line.
Then, someone from your finance team—someone you know for a fact has never coded a day in their life—casually walks in, glances at the screen, and sends you a Slack message.
“Hey, I actually built a rough version of this last week. It took me a couple of hours. Want to see?”
Wait… what?
Suddenly, you’re looking at a working prototype on their laptop that does 80% of what the vendor just pitched. It’s not perfect, but it works. And it didn’t cost a six-figure contract. It cost an afternoon. In that moment, everything you thought you knew about how software gets made, and who gets to make it, starts to feel a little shaky.
The Old Rulebook We All Lived By
For years, every growing business faced the same classic dilemma: should we build this tool ourselves, or should we just buy it off the shelf?
The logic was pretty simple and, for a long time, it made perfect sense.
You’d build if the software was absolutely core to your business—your secret sauce. But it was a huge commitment. It meant pulling your best (and busiest) engineers off other projects, writing endless specs, managing sprints, and signing up for a lifetime of maintenance and bug fixes.
So, most of the time, you’d buy. It was faster, safer, and you paid for the peace of mind that came with support and regular updates. The choice was clear because the cost and complexity of building were so incredibly high.
But that foundation is cracking. AI has come along and completely changed the math. What used to require a team of developers and weeks of work can now be done in hours by someone who just knows how to ask for what they want in plain English.
When the cost of building plummets like that, the old rulebook gets tossed right out the window. It’s not about build versus buy anymore. It’s something new, and we’re all still figuring it out.
What Happens When Anyone Can Build in Minutes?
I saw this happen firsthand on our customer experience team just last week. Someone spotted a minor bug mentioned in a customer’s Slack message. In the old world, this would have become a support ticket, sat in a queue, and waited for an engineer to get to it.
That’s not what happened.
Instead, the CX team member, who I promise you can’t tell Python from JavaScript, opened up an AI coding tool. They described the problem and the change they wanted. The AI wrote the code. They submitted it for review, and an engineer gave it a quick once-over and merged it.
From customer complaint to a live fix in production? About 15 minutes.
This is the part that really gets me. The line between “technical” and “non-technical” is getting blurrier by the day. The work that used to be a bottleneck for the engineering department is now being done by the people who are closest to the problem. This isn’t some far-off future; it’s happening right now in companies that are paying attention.
The Big Flip: How the Whole Process Gets Turned on Its Head
This is where things get really interesting, because AI hasn’t just made building easier—it has completely inverted the strategic logic we’ve used for decades.
The old way of doing things looked like this:
- Define the need. (Which often involved a lot of guessing).
- Decide whether to build or buy.
The problem was that step one was incredibly hard. You’d sit through endless demos, trying to imagine if a vendor’s solution actually solved your unique problem. You’d spend a fortune, migrate all your data, and six months later, you’d finally find out if you made the right bet.
Now, the sequence is flipped entirely on its head:
- Build a lightweight version with AI.
- Use it to truly understand what you need.
- Then decide if you still need to buy (and know exactly what to look for).
Think about that for a second. Instead of betting the farm on a sales pitch, you get to run cheap, low-risk experiments. You can figure out if the problem is even worth solving in the first place. You discover which features are genuinely valuable and which are just flashy demo fluff.
By the time you do decide to talk to vendors, you’re not just a passive audience. You’re an expert on your own problem.
How to Avoid the “Cargo Cult” AI Trap
As exciting as this is, I’m seeing a lot of companies run straight into a wall. They know they need to "do AI," so they go on a shopping spree. They buy up tools with "AI-powered" stickers, integrate a few chatbots, and think they’re transforming their business.
They’re not.
Physicist Richard Feynman had a great term for this: “cargo cult science.” After World War II, some islanders in the South Pacific built fake runways and bamboo control towers, hoping to mimic the operations they’d seen and make the cargo planes return. They had the appearance of an airport, but none of the understanding. The planes never came.
That’s what’s happening in boardrooms today. Leaders are buying AI tools without asking the most important question: “Does this fundamentally change how we work?” They’re building the fake airstrip and wondering why the magic isn’t happening.
The market is practically designed to make you fall for this. Every SaaS tool has bolted on some AI feature and now the label is almost meaningless. It’s just a checkbox, a marketing gimmick that often doesn’t create any real value.
The New Playbook: Build to Learn What to Buy
This is why the new model is so powerful. It protects you from the hype.
You don’t have to guess anymore. You don’t have to take a vendor’s word for it. You can test your own assumptions before you spend a dime.
Let’s say you’re looking at new vendor management software. Before you sit through a single demo, have someone on your team prototype the core workflow using AI tools. You might discover that your real issue is a broken process, not a lack of software. Or you might build a simple tool that’s good enough, and you don’t need to buy anything at all.
Most of the time, you’ll probably still end up buying. And that’s fine! Enterprise software exists for a reason—it handles scale, security, and support in ways a quick prototype can’t.
But now, you’ll buy with your eyes wide open. You’ll show up to that vendor demo knowing exactly what you need, what the edge cases are, and whether they truly understand your business. You’ll ask sharper questions. You’ll negotiate from a position of strength.
You’ll be choosing their tool not because you’re desperate for a solution, but because it’s genuinely better than the one you already proved you could build yourself. That single shift changes the entire dynamic.
For years, the question was simple: build or buy?
The new, smarter question is: how can we build to learn what we should buy?
This isn’t a theoretical exercise. It’s already happening. The companies that get this will move faster, waste less money, and solve problems more effectively. They’ll make fewer expensive mistakes because they’ll understand their own needs better than any salesperson ever could.
And the companies that stick to the old playbook? They’ll keep sitting through the same demos, nodding along, and hoping for the best—right up until the moment someone on their own team shows them what they built in a few hours, and the rules of the game change for good.
