I hear a version of this question constantly now, and it is usually asked with a little smirk: if I can just tell Claude “make me an API” and it does, why do I still need OpenAPI? Why do I need AsyncAPI, JSON Schema, Arazzo, overlays, Spectral, all the machine-readable ceremony, when the model can conjure the whole thing from a sentence? It is a fair question and the answer is not nostalgia. The deterministic artifacts matter more in a world of AI-generated APIs, not less, and the clearest way I know to explain why is to remember what happened the last time we let the contract get baked into the tooling instead of standing on its own.
Go back to SOAP and WSDL. The pitch there was similar in spirit — the tooling would generate everything, the contract and the code and the client would all come out of the machine together, and you would not have to think about the wire too hard. And it worked, right up until the contract was so entangled with a particular vendor’s tooling and a particular generator’s assumptions that the thing became impossible to move, impossible to reason about independently, and impossible to govern as its own artifact. The lesson was not “generation is bad.” The lesson was that when the contract only exists as a byproduct of the tooling that made it, you do not actually own the contract — the tooling owns you. A generated API whose only real description lives inside the prompt-and-model that produced it is SOAP’s mistake in a new costume.
So what does the deterministic artifact buy you that “the model made it” does not? It buys you a source of truth that exists independently of the thing that generated it. When there is a real OpenAPI, the contract is a durable object you can diff, version, lint, and govern no matter what produced it — the model, a framework, or a human at two in the morning. I have argued all year that OpenAPI is the unit of governance, and AI-generation makes that truer, because now you have a tireless machine producing APIs faster than any human review process was designed to handle. The only way to keep up is to insist that every generated API lands as a deterministic artifact you can run through Spectral, check against your rules, overlay with your policies, and hold to a standard — automatically, at machine speed. Take away the artifact and you have taken away the one place governance can grab hold. You are left trusting that the model got it right, forever, unverifiably.
And it is not one artifact, it is a whole set, each doing a job the prose cannot. OpenAPI pins the request-response contract. AsyncAPI does the same for the event-driven surfaces. JSON Schema nails the shapes. Arazzo describes the multi-step workflows so an agent does not have to rediscover the choreography. Overlays let you layer policy and enrichment onto a spec without forking it — the same move I described in overlays for MCP and agent enrichment. Spectral turns your rules into something enforceable. MCP and A2A describe how agents reach and coordinate. Every one of these is a deterministic, machine-readable statement of some part of the truth, and every one of them is more valuable when the API on the other end was generated by a probabilistic system, because the artifact is the deterministic anchor that pins down what the probabilistic thing actually produced.
This is exactly the same argument I made about agents writing deterministic integration code rather than inferring at runtime. Let the AI generate — generation is wonderful, and telling Claude to make you an API is a genuinely good way to start. But the output has to land as deterministic artifacts you own and can govern, not stay trapped as a capability that only exists as long as the model and the prompt do. The intelligence goes into producing the contract. The contract, once produced, is a boring deterministic object, and boring and deterministic is exactly what you want the thing your business depends on to be. The moment the contract only lives inside the generator, you have rebuilt the WSDL trap with a friendlier interface.
So my answer to the smirk is straightforward. Yes, tell Claude to make you an API — I do it too, and it is great. But the OpenAPI, the AsyncAPI, the JSON Schema, the Arazzo, the overlays, the Spectral rules, the MCP and A2A descriptions are not the ceremony you get to skip now that the model is smart. They are the deterministic residue that turns a clever generation into an asset you actually own, can govern, can move, and can trust in a year. AI raised the value of the contract. It did not retire it. The API Evangelist bet, which I am more confident in now than I have ever been, is that the durable, machine-readable artifact outlives every tool that generated it — and the faster we generate, the more we need the artifacts to be real.
