The realization arrived on a Tuesday in late November, during a conversation about documentation that turned into something else entirely.
Navan had been updating an NLSpec—adding a section about error handling for the Attractor event stream—when he stopped typing and stared at his screen with the expression of someone who has just noticed that the floor they're standing on is a trapdoor.
"This isn't documentation," he said.
Jay looked over. "We covered this. The spec is the product, not the documentation."
"No. I mean—yes, we covered that. But this is something different. The NLSpec isn't documentation and it isn't a product. It's an interface."
The room shifted. Justin set down his coffee.
"Go on," Justin said.
"An interface is a boundary between two systems. A contract. It defines what each side provides and expects. The NLSpec is the interface between human intent and machine execution. One side of the interface is a human who knows what the software should do. The other side is a machine that knows how to write code. The NLSpec is the surface where they meet."
"An API for humans and machines," Jay said.
"Better than an API. An API has a fixed schema. The NLSpec's schema is natural language, which means it can express anything a human can think. It's not constrained by types or endpoints or protocols. It's constrained only by the precision of the writer."
Justin was nodding slowly. "And like any interface, it can be versioned."
"Yes. And like any interface, it can be tested for compatibility. If an agent can read an NLSpec and produce code that satisfies the scenarios, the interface is compatible. If it can't, the spec needs revision—either the human side wasn't precise enough, or the machine side needs a better model."
"The NLSpec as a compatibility surface," Jay said. "That's... that changes how I think about writing them. I've been writing specs like essays. I should be writing them like contracts. Precise. Testable. Unambiguous at the interface boundary."
"Not unambiguous everywhere," Justin said. "Unambiguous at the points that matter. An interface doesn't need to specify internal implementation. It needs to specify external behavior. The NLSpec says what the software does, not how it does it. The 'how' is the machine's business."
Navan opened his notebook. He drew two rectangles, side by side. One labeled "Human." One labeled "Machine." Between them, a thin line. Above the line, he wrote: NLSpec.
"Every interface I've ever worked with," Navan said, "was defined in a programming language. This is the first interface I've seen defined in a human language. And it works because both sides can read human language now."
"That's the inflection point," Justin said. "Not when machines got smart enough to write code. When machines got smart enough to read English. Once they could read, we could write the interface in the language we think in. And that changes everything."
Navan underlined the word NLSpec in his notebook. Twice.
"The first interface defined in a human language." This is the sentence I've been waiting for someone to write. The NLSpec as the universal interface between intent and execution. My username has never felt more justified.