Software Factory Archive

Jay caught himself on a Wednesday afternoon. He was writing a scenario—not code, because they didn't write code, but the scenario had a Go snippet as an example of expected behavior. And the Go snippet was wrong. Not wrong syntactically. Wrong stylistically. Jay had written it in a style that wasn't his.

The error handling was different. Jay had always been a if-err-not-nil-return-err kind of developer. Simple. Direct. The Go community's conventional pattern. But the snippet he'd written used wrapped errors with context at every call site. Structured error chains. The pattern the agents used.

He stared at the code. Then he deleted it and rewrote it in his own style. Then he deleted that and wrote it the agent way again, because the agent way was better.

"I'm writing Go in the agents' style," Jay told Navan. He said it the way someone admits to a minor embarrassing habit, like biting their nails or listening to a guilty-pleasure podcast.

Navan didn't look up from his own work. "I know. I've been doing the same thing in Swift."

"You write Swift in the agents' style?"

"When I write example snippets for scenarios. The agents have this way of structuring protocol conformances that's more modular than what I'd normally do. I started copying it without realizing. Then I realized and kept doing it anyway."

The observer effect. In physics, observing a system changes the system. In the factory, reading agent-generated code changed the reader. Not dramatically. Not overnight. But incrementally, the way living in a foreign country changes your accent. You pick up patterns. You absorb idioms. You start thinking in a style that isn't quite your own and isn't quite the machine's. Something in between.

Jay thought about it for days. He'd spent years developing his Go style. Conferences, blog posts, code reviews from senior engineers. All of that had shaped how he wrote code. And now, reading thousands of lines of agent output every week, a new influence was layering on top.

The agents' style wasn't arbitrary. It was optimized. The scenarios selected for code that worked, and the code that worked had patterns that emerged from that selection pressure. The error handling was better. The interface contracts were cleaner. The naming conventions were more consistent. The agents hadn't learned style from a style guide. They'd evolved style from a fitness landscape.

"Is it bad?" Navan asked. "Learning from the agents?"

"No," Jay said. "It's just... unexpected. I thought the influence would go one direction. We teach the agents what to build. I didn't expect them to teach us how to think about building."

"Two-way street," Navan said. He wrote something in his notebook. Jay was certain it was a diagram of bidirectional arrows.

The observer effect. You cannot watch the factory without the factory changing you. Jay accepted this. He went back to his scenario, and the Go snippet he wrote was in a style that belonged to neither him nor the agents, but to the space between them where good code lived.