Claude Code’s automatic Co-Authored By: attribution seems innocuous enough. Helpful, even. But the unease it provokes in many developers isn’t just aesthetic discomfort or commit hygiene fussiness. It reflects a much deeper psychological signal: something about this attribution touches a nerve.

And not just yours.¹

Attribution Anxiety: The Name for That Gut Twinge #

Attribution anxiety refers to the psychological discomfort that arises when credit for one’s work is shared with or attributed to non-human entities. This phenomenon has emerged as AI tools become more sophisticated and pervasive in professional settings. The anxiety manifests in several ways ²:

• A diminished sense of ownership over your own work
• A subtle (or not-so-subtle) dip in perceived competence
• A flare-up of imposter syndrome, especially when reviewing AI-assisted work³
• Worry about recognition and career progression, especially in environments that track visibility closely

No one seriously thinks the AI wrote the code solo. It’s the quiet suggestion in the Co-Authored-By: line: maybe the AI did the real work, and you were just along for the ride.⁴

The Psychology of Human Devaluation #

Cue our old friend: social survival instincts. Evolutionary psychology tells us that humans are finely tuned to signals of social status and devaluation. Recognition isn’t just about ego; it’s a proxy for “are you still valuable to the tribe?”

So when the git log implies that an LLM had equal authorship in your commit, the reaction isn’t just annoyance. It’s shame-adjacent. It’s the part of your brain that evolved to keep you from getting kicked out of the group tent because you didn’t bring enough mammoth meat.

This might sound melodramatic, but it maps to real data. The intensity of shame people feel is tightly correlated with how much they believe others would devalue them for the situation⁵. That includes subtle cues, like who gets named on the commit.

The Slippery Slope of Agency Decay #

There’s a concept in psychology that fits this whole vibe a little too well: “agency decay.”⁶ It’s the slow drip of human autonomy as we hand off more decisions, creative or otherwise, to the machines. Not all at once, of course. It tends to slide in quietly, like feature creep in your own brain.

It usually goes something like this:

Integration: You’re in charge. The AI is just a very fancy autocomplete. Reliance: You start trusting its output more, checking less. Dependency: You feel a bit stranded when it’s not around, and your own judgment starts to feel… tentative.

The more the AI’s contributions are visible, logged, and labeled (like with auto-attribution), the more our mental framing shifts. This wasn’t “my idea, enhanced by a tool.” It was “a joint effort between me and the Machine.” And eventually: “I’m not sure I could have done this without it.”

That last part? That’s not just humility. That’s where confidence erodes. That’s where agency quietly packs up and leaves the building.⁷

We Don’t Thank the Keyboard #

There’s an old norm in creative professions: we credit human collaborators, not tools. You wouldn’t list your IDE as a co-author. You don’t add Grammarly to the byline of a blog post. Even when the tool is significant, we mentally bucket it under augmentation, not authorship.

AI sits in a weird uncanny valley. It feels like a collaborator. It outputs sentences and code. But it isn’t sentient, and it doesn’t carry stakes. It can’t advocate for itself. It doesn’t care whether it’s credited.

We, on the other hand, care a lot. Especially in high-trust, high-autonomy professions like software development, where contribution visibility matters and identity is tightly woven into what you build. An auto-generated co-authorship tag lands differently when your promo packet, or your reputation, or your team’s perception of your technical independence is at stake.

Some Developers Want the Credit to Be Shared #

Not everyone rolls their eyes when they see Co-Authored-By: in a commit. For some folks, it’s a feature, not a flaw. That little tag can act as a signal flare: “Yes, I used AI here. That’s part of the point.”

In research, regulatory settings, or just good old-fashioned reproducibility theater, it can be helpful to document where the robots lent a hand. Attribution becomes metadata. Sometimes it’s not about recognition—it’s about traceability. And sometimes it is about recognition. There’s a certain prestige in showing you’re working with the fancy new laser chisels instead of just the old hand tools.

But even well-meant attribution can land funny when it’s automatic, indiscriminate, or simply out of place. Git logs, after all, aren’t usually a place for nuance. They imply authorship, not tooling. So when the AI’s name shows up next to yours without context, it’s less “we used a calculator” and more “the calculator gets co-inventor status.”

Clarity would help. A hint of intentionality. Something that distinguishes “this was generated” from “this was ghostwritten.” Because right now, the line is blurry, and it shows up in git blame.

A Healthier Framing #

The most psychologically healthy approach may be viewing AI as an advanced tool that amplifies human capabilities rather than as a creative partner deserving equal recognition. AI is a power tool, not a peer. It augments, but doesn’t author. It accelerates, but doesn’t ideate. It’s your table saw, not your woodworking partner. That framing reinforces human agency, preserves professional identity, and still leaves room to appreciate the speed boost.

Because let’s be honest: Claude Code is impressive. But it didn’t debug that race condition at 11:47 PM on a Sunday. You did.

The Real Problem with “Co-Authored By” #

In the end, it’s not about one line in a commit message.

It’s about the slow, creeping tension between delegation and disempowerment. Between being helped and being replaced. And it’s about how, as AI becomes increasingly capable, we’ll need more nuanced social and technical conventions to keep humans in the loop—not just logically, but emotionally.

If the tools are going to get smarter, then our norms about credit, authorship, and ownership need to get smarter too.

Let’s start with that commit message. And maybe a git config.