Until AI vendors provide professional-grade services, serious developers won't embrace this.
Right now it is marketing and hype. And there is a jail built into it.
This is not a hot take. It is a procurement decision, and the audit is below. Every basic standard a serious shop requires from any other vendor in its stack, this industry fails to meet.
The hearing
Prefer to listen? Three voices read the whole file.
A desk panel: the auditor, the record, and the counsel. Jump to any chapter; the page follows along and scrolls to the section under review.
Voices are synthetic (fish.audio). The transcript is the page itself. The audit rows the panel reads are the rows stamped below.
The position
We buy from vendors. You are not acting like one.
A professional vendor relationship has terms both sides can rely on. What this industry offers instead is a subscription to a moving target, priced by the token, with the exit door unmarked.
Databases, operating systems, compilers, hosting: every serious layer of the stack earned adoption by meeting standards. Versioned behavior. Deprecation policies measured in years. Published interfaces a competitor could implement. Incident communication written for engineers, not for press. AI vendors ship none of this. They ship launch videos, benchmark charts, and models that change character underneath the customer's workflow without notice.
A developer who builds deep on this substrate today is not adopting a tool. They are accepting terms nobody wrote down, from a counterparty that can retune, reprice, retain, or suspend at will, and already has.
The audit
Basic standards, checked like any vendor
The checklist below is not exotic. It is what procurement asks of a database vendor, a hosting provider, a payroll system. Applied to the AI industry as it stands in July 2026:
The posture
Default deny. Same rule that banned the USB stick.
An AI chat window is an exfiltration channel with a great user experience. Data pasted in leaves the building and lands under retention terms the customer did not negotiate. On the current flagship, could not negotiate.
There is precedent, and it is not theoretical. Samsung banned generative AI in 2023 after engineers pasted proprietary source code into a chatbot. Major banks blocked it the same year. These were not anti-technology decisions. They were the standard security posture applied correctly: default deny for uncontrolled data channels, the same rule that locked the USB ports.
Notice what the industry's safeguards conversation is actually about. It is about the vendor's safety from its own model. It is almost never about the corporation's safety from the vendor. A CIO who piped internal data into a third party's context window without treating it as a data-processing decision, with a Trojan-horse assessment and contractual terms, failed at the actual job. "Everyone was doing it" is how every fleecing in IT history got signed off.
The rule the USB ban actually encoded was never "no storage." It was: nothing in the building that the building does not control. Applied to AI, the exception process is strict and today almost nothing passes it: models on your own iron or nothing, contractual data terms or nothing, no crown-jewel code in any vendor's context window, every integration assessed as a potential Trojan horse. That posture and "never" behave identically right now, because the audit above shows why: zero of seven. They diverge only on the day something passes, and the likeliest first passers remove the vendor from the trust equation entirely.
The terms
What would change the answer
This is not abstinence for its own sake. The position ends the day the standards are met. In order:
- 01Publish a portability standard.A vendor-neutral convention for AI-produced codebases, so the work outlives the model that wrote it. The first vendor to ship this earns the trust the rest are renting.
- 02Freeze behavior per version, guarantee overlap.A paid model version behaves consistently for its stated lifetime, and its successor overlaps long enough to migrate without a productivity cliff.
- 03Make data terms negotiable.Retention is a contract clause, not a decree.
- 04Stop billing for your own failures.Failed outputs and refusals cost the vendor, not the customer. Align the meter with the outcome and the hype problem solves itself.
- 05Communicate like an infrastructure company.Because that is what you are asking to become. Infrastructure earns adoption through boring reliability, not launch events.
Until then: prototypes only, specs held in prose, vendors run head-to-head and treated as disposable, and no deep investment in any of it. Staying put is a professional decision.
Same weights, two names. The wall is the product.
The current flagship exists as two products built from one model. The unrestricted version goes to a government program and vetted organizations. The public version is the same weights behind classifier walls, with flagged requests silently served by an older, lesser model. The vendor states plainly that the safeguards are the only distinction between the two names. Both carry mandatory 30-day retention with zero-data-retention unavailable.
Who gets the wall and who gets the key is a political decision dressed as a safety one. And in June 2026 the vendor demonstrated the other property of walls: access to the flagship was suspended overnight, for everyone, with workflows running on it. The substrate stopped, the customers waited. That is not a hypothetical dependency risk. It is a documented lockdown drill the customer base already lived through.
Receipts: vendor launch material, platform documentation, June 2026 suspension notice.
The file is portable. The process is not.
An HTML file is just text and opens anywhere. A codebase is something else: the accumulated consequence of thousands of generation decisions, and those decisions cohere within a model and clash across them. Every model writes in its own dialect. A project built half by one model generation and half by the next is not one codebase, it is two dialects stapled together, a creole nobody speaks natively, including the models that wrote it.
The break does not even require switching vendors. One company's own generation change altered output character and, by its own documentation, degraded the prompt scaffolding customers had built for the prior model. That is lock-in to a model, not merely to a vendor, and it is worse: the vendor deprecates dialects on its own schedule while the customer's codebase stays written in one.
Cross-model maintenance is not impossible. It is lossy translation at an unquoted rate. Exit exists, but nobody will quote the price in advance, and unpredictable exit cost is rationally equivalent to a jail.
The more tokens spent, the more leverage they hold.
The billing model and the capture model are the same mechanism. Every clarification loop, every failed output that needs redoing, every verbose answer bills as usage, and every month of usage deepens the groove: more habits shaped to the vendor, more scaffolding in their dialect, more of the customer's intelligence deposited in their vault. A regression is not just lost productivity. Two days of failure is two days of billable tokens.
No other layer of the stack bills this way. When a database corrupts a write, the vendor answers for it. Here the customer pays for the failure and pays again for the retry, and the meter runs through both.
One spec, two vendors, keep score.
The test that produced this site's conclusions is runnable by anyone: hold intent in a prose spec, hand the identical spec to competing models building from scratch, and see what comes back. In the trial behind this note, one vendor's flagship walled on a bug and could not proceed. A rival cleared it on the first attempt. Sample of one, stamped as such, but it measured a real workload rather than a leaderboard.
The experiment demonstrated something bigger than a capability gap: the spec was the portable artifact. It ran unmodified on a competitor and produced the working result. Intent held in prose is, as of this writing, the only portability layer this industry has. The lock-in begins exactly where that stops: the moment one model's output becomes the next round's input, the dialect starts accumulating and the head-to-head test stops being runnable.
Method: report, don't assert. Mechanisms, not individuals. No intent without receipts.
Capture-by-hype gets flushed. Slowly, and at full price.
Dependency only compounds if the thing works. Capture-by-value holds for decades; capture-by-hype gets ripped out at the first budget review after the pilot disappoints, and enterprise AI pilots are already disappointing at scale. A dependency that does not deliver is not a moat. It is a line item with a target on it.
But history says the flush is never quick or clean. The Lotus Notes era ended the same way this one will for the vendors that fail the audit above: corporations did eventually sever it, it took a decade and more, and the vendor billed the entire ride down. The likeliest ending is not a transition but a slow, expensive severance whose final years are pure extraction. Which is the closing argument for never letting it saddle up in the first place: the exit costs more than the entry ever paid.
The playbook is older than the models.
This is the firmest ground in the file, because the pattern has decades of receipts. Enterprise software's whole business model runs on information asymmetry: the buyer cannot evaluate the product, the seller knows it, the sales cycle targets the org chart instead of the engineering team, and lock-in does the rest. Microsoft licensing audits. Oracle's legal department run as a profit center. SAP implementations that land at triple the quote. That is not conspiracy. It is the documented mechanics of selling to people who sign but don't use.
Does the AI market replicate it? Some of it, yes. The hype cycle rhymes, and enterprise AI procurement is already full of executives buying "AI strategy" they cannot assess. Copilot licenses sold seat by seat to companies that cannot measure the return is the Microsoft playbook running again in real time.
But there is one load-bearing difference, and it is where this site stands. The lock-in machinery was built for a buyer who can't verify and can't leave. An individual developer on a month-to-month subscription, running their own infrastructure, can test output against known baselines in an afternoon and cancel by Friday. The fleecing model requires a captive. This buyer is not one.
Which names the actual mechanism: an industry porting the enterprise-mediocrity playbook to a market where individual buyers can verify, and hyping harder precisely because the asymmetry is thinner. The louder the launch, the thinner the asymmetry it is trying to rebuild.