Jay found the pattern on a Tuesday. It was buried in the Leash codebase—a particular way of handling graceful shutdown that accounted for in-flight syscall monitors, pending Cedar policy evaluations, and half-finished MCP observations all at once. The shutdown sequence didn't just stop things. It unwound them, layer by layer, in dependency order, waiting for each layer to confirm quiescence before moving to the next.
It was, Jay realized, the cleanest concurrent teardown he'd ever seen. And an agent had written it.
He leaned back in his chair and stared at the ceiling. The CXDB gateway had a shutdown problem. The Go gateway would occasionally drop in-flight requests when the process received SIGTERM, because the HTTP server's graceful shutdown and the binary protocol listener's shutdown weren't coordinated. Two teardown paths, no synchronization between them. He'd described the problem to agents three times. Each time they'd produced something that worked but felt brittle—race conditions hiding behind generous timeouts.
But this. This pattern in Leash. It wasn't about containers or syscalls. It was about the shape of the problem: multiple concurrent subsystems that needed to drain in a specific order, with confirmation at each stage.
"Justin," Jay said across the office. "I want to try something."
He didn't copy the code. That would have been pointless—Leash was a Node.js and Go hybrid, CXDB's gateway was pure Go, and the subsystems being shut down were entirely different. Instead, Jay wrote a description. Not of the code, but of the pattern. The layered quiescence protocol. The dependency-ordered drain. The confirmation callbacks. The timeout escalation strategy.
He fed the description to an agent along with the CXDB gateway's architecture, and asked it to implement the same pattern in the gateway's shutdown path.
The agent produced something in eleven minutes. Jay ran the scenarios. Every single graceful shutdown scenario passed. No dropped requests. No race conditions. No generous timeouts papering over coordination failures.
"That's a gene transfusion," Justin said, reading over Jay's shoulder. He said it matter-of-factly, like he was naming a bird he'd spotted in his garden. "You extracted a working pattern from one codebase and transplanted it into another. Not the code. The pattern."
"The agent did the transplanting," Jay corrected.
"The agent did the implementation. You did the recognition." Justin tapped the screen where Jay's pattern description sat. "That document right there—that's the gene. The description of the pattern, abstracted from its original context, ready to be expressed in a new one."
Navan had been listening from his desk. "So we should be cataloging these."
"Yes," Justin said.
"Not the code."
"Never the code. The code is the phenotype. It's expressed differently in every codebase. What you catalog is the genotype—the abstract pattern that produces the right phenotype in any environment."
Jay saved the pattern description to a new directory. It was the first entry. He didn't know it yet, but within three months there would be forty-seven more. Each one a proven solution, extracted from where it worked, ready to be transplanted into where it was needed.
The technique that accelerated everything started with a Tuesday afternoon and a clean shutdown.
The genotype/phenotype metaphor is perfect. You're not copying code, you're describing the *shape* of a solution. The agent handles the translation into whatever language and context it needs to land in.