The argument I keep seeing goes like this. AI killed software development as a craft because it killed pair programming. The shared screen, the Nerf gun fights, the senior dev sighing through your third explanation of why your loop is off by one. Gone. In their place: a developer alone with a chat window, shipping code that used to require a team.
I read a piece making this case recently. The author was honest about the upside (more time with his family, more autonomy) before getting to the loss: the camaraderie of solving problems with other people. "That shared moment of triumph when the div is finally centered," as he put it. The line stuck with me because I recognized the feeling, even as I disagreed with where he took it.
The framing assumes that the way collaboration looked in 2019 is the only way it can look. It isn't. It's the way that suited a specific moment, when the tools required more humans to produce the same output. The tools changed. The work changed. The shape of collaboration is changing with them.
Every meaningful technological shift compresses the labor and expands the surface. Fire didn't eliminate cooperation by making meat easier to chew. It produced culinary science, food preservation, and an entirely new domain for humans to organize around. The printing press didn't isolate writers. It built the publishing industry and broadcast their collaboration to an audience that didn't exist before. The internet didn't end community. It rearranged it.
AI-assisted development belongs in that lineage, not in an exceptional category where the rules don't apply.
Here's what collaboration actually looks like in my work now.
I still talk through problems with other developers, but the unit of discussion has changed. I'm not asking how to write a function. Claude handles that. I'm asking whether the architecture I'm proposing is right for where the product is going. That's a much more interesting question, and one humans are still better equipped to answer.
I still get feedback on what I ship, but the loop is faster. I can have a working prototype in front of a client by the next call instead of in two weeks. The conversation that happens around that prototype is more substantive because we're talking about real software, not slides.
I work with people I wouldn't have had access to before. Founders who couldn't afford a developer can afford me now, because I can deliver in weeks what would have taken a team months. The collaborative network is wider, not narrower.
I also collaborate with the AI itself. That phrasing sits weird with some people, but it's accurate. Claude pushes back, suggests alternatives, catches things I miss. It isn't pair programming the way it was practiced in 2019. It also isn't nothing.
The senior dev groaning at your off-by-one error is mostly dead. Pair programming as it was practiced is going the way of the typing pool. Both of those losses are real. Neither of them means collaboration is over.
The choice isn't between the old way of working and isolation. It's between mourning what changed and using the new tools to do work that wasn't possible before. The first tribe to discover fire didn't extinguish it because it threatened their bonding rituals. They sat around it. They cooked together. They started telling stories.
We've discovered our new fire. The question isn't whether to use it. It's what we do with the time we used to spend chewing.