AI products need documentation and APIs that language models can read and use directly.
2
Simple formats such as Markdown, curl, OpenAPI, and established technologies give language models clearer instructions.
3
Product teams should remove account limits for legitimate paid users and expose useful data, including pricing, through APIs.
Summary
Zeke Sikelianos uses Andrej Karpathy's MenuGen app as a test of AI developer experiences. Karpathy built the app quickly as a local demo, then found deployment difficult because several services had outdated documentation, API changes, rate limits, and account restrictions. Sikelianos argues that products now need to be designed for language models as well as human users. Replicate responded by adding Markdown copying, links to Claude and ChatGPT, and an MCP server built from its OpenAPI schema. Sikelianos recommends publishing concise machine-readable documentation, supporting curl, using established technologies, and keeping API responses small and information-dense. He is also direct about Replicate's mistakes: a legitimate paid user was blocked after generating many images, and important product information such as pricing was not available through the API. The talk treats these failures as practical design problems that teams can fix through better documentation, APIs, and account policies.
MenuGen was easy to build locally and painful to run as a real service
Andrej Karpathy created MenuGen as a vibe-coding experiment. The app takes a photo of a restaurant menu and generates image representations of the dishes, which can help people who do not know the language or want to see the food. Karpathy described the local demo as an "exhilarating and fun escapade" and the deployed application as "a bit of a painful slog." Sikelianos uses that contrast to focus on the problems that appear when a working prototype meets hosting, APIs, payments, and production limits.
Outdated documentation makes AI-generated integration fail before the code starts
Karpathy found that the language model's knowledge of Replicate was outdated, Replicate's documentation was out of date, and the API had changed. He also ran into rate limiting and difficulty creating a new legitimate paid account. Sikelianos says these are product problems worth fixing, even though it was uncomfortable to see Replicate mentioned alongside larger companies in Karpathy's criticism. His response is to make product information easier for language models to consume and use.
Machine-readable documentation should be plain, current, and easy to copy
Sikelianos recommends llm.txt, a text or Markdown version of documentation designed for language models. He contrasts a tired, elaborate documentation page with "one single docs markdown file and a copy to clipboard button." Replicate added a button on model pages to copy the page as Markdown, plus links that send the page to Claude or ChatGPT. Developers can also paste the Markdown into tools such as Cursor or Windsurf so the editor can understand how to run the model.
curl gives language models a complete recipe for making an API request
Sikelianos says language models do not like to click and prefer to use curl. A curl command may look unattractive, but one line contains the HTTP method, JSON payload, credentials, response type, blocking or asynchronous behavior, and API endpoint. That makes it useful training material and direct instruction for a language model. His example is a reminder that familiar command-line interfaces can be easier for an AI system to use than a visual product flow.
An OpenAPI schema can power documentation, editors, and MCP tools
Cog, an open-source tool from cog.run, packages machine-learning models in production-ready Docker containers and creates a standardized API with OpenAPI inputs and outputs. Sikelianos describes putting Cog's documentation into a single llm.txt file so an editor can use it while modifying an existing model. He then explains MCP as a way to put an OpenAPI schema into a format that tells a language model what actions it can take. Replicate's MCP server lets Claude work with the Replicate API after the user adds a small JSON configuration and an API token.
Good API schemas make language-model discovery and tool use possible
Sikelianos says Replicate did not need to build a separate product description for every MCP interaction. It needed a well-written, well-documented OpenAPI schema covering what the API can do. That schema can support discovery, searches, project scaffolding, and actions through Claude, GitHub Copilot, and Visual Studio Code. He expects MCP support to spread to more tools, including OpenAI's Agents SDK, because it gives language models a structured way to use services.
Paid users should not be blocked by an abuse system that ignores context
Karpathy signed up, added a credit card, and then sent many image-generation requests for MenuGen. Replicate's abuse system saw that a new account had sent roughly a thousand requests in an hour and blocked it. Replicate's CEO noticed the blog post and unblocked him, but Sikelianos points out that most users cannot publish a widely read blog post to get that response. His proposed fix is to let a user pay for credits, then use them freely without being treated as abuse.
APIs should expose compact information that models can use for decisions
Sikelianos asks teams to document features when they ship them, feed machines content in formats they can consume, and use established technologies such as SQL. He also recommends API hygiene: responses should fit within a language model's context window and contain dense, useful information instead of every possible field. In the question period, he applies this to model discovery. If pricing, speed, and quality information are exposed as structured API data, Claude could compare models and help someone choose between them.
"The primary audience of your thing, your product, service, library, etc. is now an LLM, not a human."09:31
Who should watch
You maintain an API, SDK, or developer tool that AI coding systems need to understand.
Your documentation looks polished in a browser but is difficult to copy into an editor or language model.
You are building account limits, model discovery, or purchasing flows and need those functions to work through an API.
