Buy vs build when AI compresses build time: what fails first

Buy commodities. Build the harness that makes your judgment visible: policy, evals, audit, and exit.

I will stay on this thesis — no adjacent manifesto, no tour of every neighboring discipline.

On Buy vs build when AI compresses build time, start from ownership of the failure mode and the exit path. Purchase price is the down payment; integration debt is the mortgage.

Keep harnesses you control — evals, policy, audit — even when you buy commodity inference or platforms. That is how judgment stays portable.

Practices with enough detail to copy

Cadence beats intensity. These hold when they fit inside weeks people already live.

1

Every purchase: name the internal owner and the failure-mode runbook.

Build the harness, buy the commodity: keep eval suites, policy, and audit logs in systems you control even if inference is purchased.

2

Require eval and audit ownership to stay in-house for AI tooling.

When a vendor becomes your process, document the process in your words. Otherwise a price hike or outage becomes an identity crisis.

3

Every build: name the commodity you refused to buy and why ownership differs.

Evaluating vendors like critical-path systems includes asking how you pause them. No pause path means no operational maturity.

4

Annual: run a tabletop exit for one critical vendor.

Exit drills are cheap insurance. Export a sample, revoke a key, and time how long a degraded mode lasts before you need the vendor again.

Integration debt belongs on the same board as features until retired. Otherwise procurement wins the quarter and on-call pays the year.

Start from ownership. If nobody on your team can operate the failure mode, you did not buy a capability — you rented a demo with a support email.

Write one page while the decision is still warm — context, options, choice, owner, revisit date. Verbal alignment on Buy vs build when AI compresses build time evaporates under ordinary calendar pressure, and Slack archaeology is a poor substitute for a decision record.

Scenes

Integration debt after purchase: five half-connected identity paths and no single owner for authz bugs. Procurement celebrated; on-call paid.

No exit plan. Price increases. Suddenly “switching costs” are discovered during budget season. A tabletop unwind once a year is cheaper than surprise.

A price hike arrives and nobody can list what data is trapped where. The exit sketch should have been written at purchase, not at panic.

Tradeoffs

Keeping harnesses in-house costs engineering time and preserves exit. Worth it for anything on the critical path.

Building custom feels like control and often buys maintenance. Buying feels like speed and often buys integration debt. Name the debt either way.

Vendor features arrive fast. Your process still needs translation into owned runbooks.

When pressure rises, teams drop the unowned practice first. Put Buy vs build when AI compresses build time in the path of work — templates, checklists, review norms — or admit it was optional applause.

If nobody on your team can operate the failure mode, you did not buy a capability — you rented a demo with a support email.

Failure modes

Each of these is a missing control, not a personality problem:

• No exit plan; switching costs discovered during an outage or a price hike.
• Building because pride, buying because fear — neither from ownership analysis.
• Vendor success metrics replacing your product metrics.
• Shadow purchases by teams that skip security and data review.

Evaluate AI vendors like critical-path systems: SLOs, incident communication, subprocessors, kill switches, and data boundaries.

The new cost of custom is maintenance, not typing. AI makes that easy to forget until the second quarter of on-call.

Platforms you buy still need owners — for identity integration, data retention, incident comms, and process translation. Procurement does not create ownership.

Make-or-buy with agents in the mix still requires you to define tool allow-lists and human override. Buying the runtime does not buy judgment.

Keep eval suites and audit logs in systems you control even when inference is purchased. That is how you keep judgment portable.

Price integration debt explicitly: connectors, identity, logging, eval wiring, and the people who will babysit them. Purchase price is the down payment.

Build less, own more of the outcome: prefer thin custom layers over reimplementing commodity models. Copilots make greenfield look cheap until on-call inherits it.

Write exit strategies for bought AI tooling before procurement: data export, prompt/eval portability, and a 90-day unwind drill. Soft lock-in is still lock-in.

Build the harness, buy the commodity works until someone rebuilds the commodity “for flexibility.” Flexibility without differentiated ownership is usually nostalgia.

A team builds a custom agent platform because it feels strategic. Six months later they maintain auth, quotas, and UI chrome instead of product differentiation. Commodity inference plus an in-house harness would have been enough.

A vendor’s success metrics replace product metrics in leadership reviews. That is lock-in of attention. Keep your north-star metrics in-house.

One more practice worth installing: Track integration debt items on the same board as features until retired.

Optimism without an owner is how demos become liabilities. Name the human before you name the tool.

The point of writing this down is not documentation theater. It is so the next person does not have to reconstruct intent from Slack.

Close

Harnesses outlive vendors. Invest accordingly.

On Buy vs build when AI compresses build time, keep the loop short: write the decision, name the owner, verify the outcome.