Navan disagreed with the design document.
It was a small disagreement. The generated overview.md described a Gopher selector parser that validated input using regular expressions. Navan had built Gopher parsers before, in Swift, and he knew from experience that regex-based validation of Gopher selectors was fragile. The selector format had enough edge cases—especially around the tab-delimited fields and the handling of empty selectors—that a proper state machine was worth the extra complexity.
In any other system, this would have been a problem. You'd file an issue, or rewrite the prompt, or tweak the configuration, or start over. The generated artifact was the system's output, and the system's output was not yours to touch.
Navan opened the design document in his editor. He deleted the paragraph about regex-based validation. He wrote a new paragraph describing a state machine approach, with explicit handling for tab delimiters, empty fields, and the various Gopher item types. He saved the file.
Then he ran agate auto.
The system read the design document—his version of the design document, with his edits—and continued. The sprint plan that emerged reflected the state machine architecture. The implementation used a state machine. The tests validated state transitions. His edit had propagated through the entire pipeline.
"It respected the change," Navan told Jay, surprised despite himself.
"Every file Agate generates is user-editable," Jay said. "The interview. The design. The sprint plan. You can hand-edit any of them and the agents will work from your version instead of theirs."
"That's... a lot of trust."
"Trust in both directions. The system trusts that your edits are intentional. You trust that the system will respect them. If you edit the design, the system assumes you know better than its first pass. It adapts."
Navan thought about this. It meant the generated artifacts weren't sacred. They weren't locked behind an API or protected by access controls. They were markdown files on disk, and they belonged to whoever held the keyboard. The agents were collaborators, not authorities. They proposed; the human disposed.
He tested it further. He edited the sprint plan, reordering the tasks to prioritize test generation before implementation. Agate adapted. He edited the interview responses, adding a clarification he'd thought of after the fact. Agate re-read the responses and incorporated the new information into the next sprint.
Every file was a conversation. The agents spoke first, but the human always had the last word.
"This is the part that makes it feel like a tool instead of an oracle," Navan said, closing his editor. "It suggests. I decide. And it listens."
He wrote in his notebook: User-editable generated files. Agents adapt to human edits. Not an oracle. A collaborator.
Navan knowing that regex is wrong for Gopher selector parsing because he's built this before in Swift is the kind of domain expertise that agents can't replicate. The system's design is smart enough to defer to that.