Somewhere in the last couple of years, a strange sentence became normal in engineering channels: "I kicked off the agent, I will check on it after lunch." Nobody blinked. That sentence would have been science fiction shortly before it became a status update, and the speed of its normalization is the story. AI pair programming did not arrive with a culture attached. Developers built one around it, in real time, mostly through trial, error, and memes. This is a field report.
The day-to-day actually changed
The old rhythm of programming was continuous: read, type, run, swear, repeat. The agentic rhythm is punctuated. You describe a task to a tool like Claude Code, review its plan, and let it work while your attention goes elsewhere. The unit of programming shifted from the keystroke toward the decision, and the workday reorganized around it.
This produced a genuinely new feeling that developers struggled to name at first, the specific idleness of watching an agent work. It resembles watching a build, except the build is writing your code. Some people fill the gap with a second task, and a subset have discovered they can run multiple agents at once, which turns a programmer into something closer to an air traffic controller with opinions about naming.
Code review became the job
When machines write more of the code, humans read more of it, and reviewing became the load-bearing skill. The engineers thriving in this era are the ones with taste: the ability to look at a plausible diff and sense the wrongness in it, the missing edge case, the abstraction that will hurt in six months. Plausible is the operative word. Agent code fails less by being obviously broken and more by being confidently almost right.
Team norms are still catching up. Review etiquette evolved for human authors, and nobody feels bad hurting an agent's feelings, so reviews of agent-written code became refreshingly blunt. The etiquette question that remains unsettled is between the humans: whether "the agent wrote it" is an explanation, an excuse, or a confession depends heavily on whether the tests passed.
The deeper shift is accountability. Authorship blurred, and responsibility did not, so the person who merged the code owns the code, whoever or whatever typed it. Most teams arrived at this rule quickly and without ceremony, because the alternative, a production incident with no owner, was unthinkable enough to settle the debate in advance.
The PR got bigger and the standup got weirder
Pull requests grew, because agents produce complete changes rather than incremental ones, and reviewers learned to ask for the plan along with the diff. Commit history became a collaboration record, and teams started documenting their conventions in files meant for the agent as much as for people, the CLAUDE.md file being the canonical example. Writing documentation that your tools actually read turns out to be excellent motivation for keeping documentation current, a problem the industry failed to solve for fifty years until the reader stopped being optional.
Standups changed flavor too. "What did you do yesterday" now has answers like "I reviewed four hundred lines I did not write and rejected half of them," which is both a normal day and a sentence from a dystopian novella, depending on your mood.
Where the jokes come from
Every workplace culture metabolizes its anxieties into humor, and agentic coding provided rich ore. The jokes cluster around a few honest tensions. There is the pride-adjacent shame of vibe coding, shipping something excellent and being slightly unable to explain it. There is the trust question, captured in a thousand memes about letting the agent run unsupervised. There is the identity question underneath it all: if the agent types, what exactly am I? The consensus answer, "the one with taste and the deploy keys," is reassuring enough to print on things.
And print it we do. Merch is how developer culture archives its inflection points, and this one is generating material faster than any shift since the web itself. Our Vibe Coder Hoodie exists because the term stopped being an insult and became a self-description. That transition, insult to identity, is how you know a culture has actually absorbed something.
What stays human
Strip away the discourse and the division of labor is settling into something recognizable. The agents handle translation from intent to implementation, and the humans handle intent: what to build, what correct means, what is worth the complexity, when to say no. Judgment, context, and responsibility did not get automated. They got concentrated.
The learning question is the one worth watching. Junior developers used to absorb the craft by typing it, mistake by mistake, and the honest concern is what happens when the mistakes get outsourced. The early answer seems to be that the craft moved rather than vanished: juniors now learn by reading enormous volumes of agent-written code and developing the review instincts that used to take a decade, faster and differently than their mentors did. Whether that produces better engineers or just different ones is a question the industry will answer by living through it.
Which may be why the culture, for all its jokes about obsolescence, feels less anxious than it did at the start. The work changed shape and remained work. The terminal is still open, the opinions are still strong, and the shirts still get printed. Some things about this profession were never really about the typing.
