Code Is the LLM

Three phases

Karim Atiyeh names three phases in how companies build with AI, and the third is the one that matters. In phase one, the LLM is an assistant: you write the same code you always wrote, a little faster, copy-pasting from a chat model or reviewing a larger diff produced by an agentic IDE. The artifact is still hand-shaped software, and the model is a tool that helps you type it.

In phase three, the LLM is the product. You stop writing that code at all and instead program the model directly: "Your code is the LLM now. Your code is the LLM plus instructions and an infinite loop." The deliverable is no longer a codebase that calls a model occasionally, it is instructions plus tools plus a loop, where the model's reasoning is the runtime: "you're essentially writing those agents like that." Atiyeh, speaking on Invest Like the Best in 2026, describes Ramp as being "in the middle of that right now."¹

The canonical example: the policy agent

Atiyeh's worked example is Ramp's policy agent, and it makes the abstraction concrete. The program is a prose document: a company's travel and expense policy is "essentially a document you write to drive the behaviors of people." In the old world a human reads it, imperfectly and from memory, and adjudicates transactions manually with a lot of missing context and back and forth.

The instructions are that plain-English policy itself. The tools give the agent more context than any human reviewer would have, since it is integrated with the company's calendar and email and knows the policy better than any employee does. The loop runs around the clock as transactions arrive, classifying each as in or out of policy far more efficiently than a person could. And the program rewrites itself: as it runs, it gets better at advising how to make the policy clearer, so the company ends up with "this living, breathing text document that can evolve over time." The English is the source code, continuously refactored.¹

The same shape generalizes to undocumented work: invoice-fraud checks, did-we-order-it, did-we-receive-it, does-the-price-match. Because so many customers run their finances on Ramp, the company can infer these unwritten policies from behavior and ship them as the next generation of agents.

Why it matters

This relocates the unit of engineering from lines of code to instructions plus tools plus loop. It is the operator-side complement to the idea that English is becoming a programming language: where a purely code-centric framing treats the artifact as what matters, Atiyeh's framing treats the runtime, the model itself, as the program. If the product is instructions plus tools plus a loop, what ships is work done (an expense reviewed, an invoice cleared), not a feature a human has to operate. And the program improving its own specification, the policy document getting clearer as the agent runs, is a bounded but real form of a system that compounds with a human still in the loop.

Tensions

A prose "program" inherits the model's judgment and is non-deterministic, which is why this paradigm needs to live on a fast-iterate, allowed-to-break side of a system, never on money rails that must never break. The claim that more context produces better classification assumes the tools genuinely encode the right context and that the model weighs it the way the company's values would. And pricing this kind of product is unsolved: Atiyeh warns against charging by tokens or time, since that rewards inefficient loops, and argues instead for charging by task complexity, an open problem for the entire category.