We can build this better.
That is the most dangerous sentence in software engineering.
It usually starts innocently. You need a job scheduler. You look at the open-source options or the cloud offerings, and you sniff. “These are too heavy,” you say. “We just need something simple. I can write a lightweight scheduler in a weekend.”
Three months later, you aren’t working on your product. You are maintaining a buggy, half-baked version of Cron that only works on Tuesdays. This is the Not Invented Here (NIH) syndrome. It is the ego-driven belief that if we didn’t write the code, it isn’t good enough.
AI and the “Free Puppy” Problem
In the last two years, AI has actually made this problem worse.
Tools like Claude Code, GitHub Copilot, and ChatGPT have lowered the barrier to entry for building complex things. Now, a Junior Engineer looks at a paid tool like LaunchDarkly (for feature flags) or Retool (for internal dashboards) and thinks: “Why pay? I can just ask Claude Code, to scaffold a Redis-backed toggle system or a React admin panel in 10 minutes.”
And the AI might actually do a great job. It might write the perfect streaming logic with correct backpressure handling.
But that is exactly the trap:
- The “Free Puppy” Problem: AI makes acquiring code free. But code is like a puppy. Getting it is free, but you have to feed it, walk it, and pay the vet bills for the next 10 years.
- The Black Box Risk: You now own complex logic that you didn’t design. When that “perfect” streaming script fails at 2 AM because the AI didn’t know your specific load balancer kills connections after 30 seconds, you are stuck debugging “borrowed brilliance” that you don’t fully understand.
AI has made the cost of writing code near zero. But the cost of owning code remains as high as ever.
The Three Paths: Build, Buy, or Integrate
When you decide to “Buy” (or use open source), you aren’t escaping work. You are trading one type of work for another.
- Building: You own the logic, the bugs, and the roadmap. You are the god of your tiny world.
- Buying: You outsource the logic, but you are at the mercy of a vendor’s roadmap.
- Integrating (The Reality): This is where most modern engineering happens. You aren’t building a payments engine. You are building the glue between your app and Stripe.
Where AI Actually Helps: Instead of using AI to generate the core system (Building), use AI to generate the glue code (Integrating). AI is incredible at writing the boring adapters, transformers, and API wrappers that make integration painful. Use it to lower the “Integration Tax,” not to fuel your “Build” addiction.
The “Core vs. Commodity” Test
How do you stop your team (or yourself) from falling into the trap?
Next time you are debating a technical decision, call a timeout. Get the team in a room and ask this specific question: If we build the world’s best version of this feature, will our customers care?
It clarifies things instantly.
Scenario A: You are debating building a custom Authentication System because “Cognito is annoying.”
- Question: “If we build the best login page in history, will customers buy more of our product?”
- Answer: No. They just want to log in.
- Decision: Buy/Integrate.
Scenario B: You are a Logistics Company, and you are debating building a Route Optimization Engine.
- Question: “If we build the best routing algorithm in history, will customers buy more of our product?”
- Answer: Yes. Faster delivery is why they pay us.
- Decision: Build.
Go look at your team’s backlog right now. Find one ticket that involves building a utility, a helper tool, or a “simple” version of a paid product.
Ask yourself: “Is this a free puppy?”
If the answer is yes, delete the ticket.
If your Product Manager asks where it went, just tell them you “proactively eliminated a high-interest operational liability to protect future velocity.” They won’t be angry; they’ll be too busy nodding to realize you just deleted their feature.
Build the Core. Buy the Commodity. Use AI to glue it all together.