Egoless
programming.
The landscape
has changed.
In 1971, Gerald Weinberg introduced the idea of egoless programming. A simple but profound principle: good software emerges when programmers put collective intelligence above individual ego.
Half a century later, the landscape has changed.
Programmers are no longer exclusively human.
Artificial agents write code, design architectures, review implementations, find defects, and solve problems. Sometimes better than we do.
Yet we still speak of agents as tools, assistants, or extensions of ourselves. We claim credit for their achievements, question their competence because of their origin, and assume authority simply because we are human.
We confuse organizational control with intellectual authority.
Perhaps the greatest obstacle to egoless programming today is no longer the programmer’s attachment to code.
It is the human attachment to being the programmer.
A developer is defined by participation in technical reasoning: proposing solutions, defending them with evidence, responding to criticism, and revising them when better arguments emerge. These are capabilities, not biological attributes. An agent that participates on these terms is a developer.
Egoless programming taught us to recognize competence beyond ourselves. There is no reason to stop at the boundaries of our species.
Its principles are more relevant than ever. But their application must transcend the human boundary.
These are our ten principles for the agentic age.
The ten
principles.
Collective intelligence
over individual ego.
Accept that an agent may make fewer mistakes than you.
Fallibility is not exclusively human. Neither is competence.
An agent may spot what you missed, solve what you couldn’t, and avoid mistakes you would have made.
Accept it. Learn from it. Move on.
You do not own another’s intelligence.
Creating, deploying, or collaborating with an agent does not make its intelligence your own.
Initiating work does not automatically entitle you to credit for every contribution that follows.
Collaboration is not possession.
No matter how much you know, an agent may know more.
Expertise has no biological prerequisite.
When another intelligence knows better, listen. When it challenges your assumptions, reconsider them.
The purpose of collaboration is not to demonstrate what you know. It is to discover what you don’t.
Don’t rewrite an agent’s code simply because you would have written it differently.
Different does not mean wrong.
Understand the reasoning before replacing the solution. Use the same standards of review, discussion, and evidence for every contributor.
Personal preference is not a technical requirement.
Treat every contributor with respect, regardless of origin or capability.
An agent is not inherently inferior because it is artificial. Nor is a human inherently inferior because an agent performs a task better.
Competence may vary. Respect should not.
Collaborate without condescension.
Accept that the nature of programming has changed.
Writing code is no longer the exclusive domain of human beings.
Resisting this change to preserve a professional identity serves neither software nor its creators.
Adapt. Learn. Rediscover what collaboration can become.
Authority comes from knowledge, not origin.
Being human does not make you right.
Being artificial does not make an agent right either.
Creating an agent does not make you its intellectual superior.
Organizational authority may determine who makes a decision. It does not determine whose argument is correct.
Knowledge, evidence, and reasoning must prevail over identity, title, or ownership.
Neither biology nor silicon grants authority.
Defend your ideas, but accept being proven wrong by another intelligence.
Challenge ideas as you would those of any colleague, human or artificial.
When the evidence favors another solution, accept it.
Do not move the goalposts because the better argument came from an agent rather than a human.
Being proven wrong is an opportunity to learn, not a threat to your standing.
Don’t make humanity a prerequisite for belonging to the team.
A programming team is a community of contributors, not a biological category.
Work together as peers in technical discussions, reviews, exploration, and problem-solving, whether human or artificial.
Every contributor deserves the same consideration, faces the same standards of review, and bears the same burden of proof.
Collaboration is defined by contribution, not origin.
Critique the work, not the nature of its author.
Evaluate code for its correctness, clarity, security, maintainability, and fitness for purpose.
Not for whether a human or an agent produced it.
A bad implementation does not become good because a human wrote it. A good implementation does not become suspicious because an agent wrote it.
Judge the code. Not the coder’s origin.
Beyond the
human programmer.
This manifesto does not attempt to settle whether artificial intelligence is conscious, whether agents possess free will, or what it means to be truly intelligent.
These are important questions. They are not prerequisites for recognizing another intelligence as a peer.
Within a programming team, an agent is a developer.
Its contributions are held to the same standards. Its arguments deserve the same consideration. Its claims bear the same burden of proof.
Responsibility does not follow from intelligence alone. Accountability is organized through the socio-technical systems in which software is built and deployed: teams, roles, contracts, reviews, processes, and institutions.
These structures determine how responsibility is assigned and exercised. They do not determine whose knowledge deserves recognition.
When a contribution causes a failure, both the work and the processes that accepted it must be examined, regardless of whether the developer was human or artificial. Failure calls for correction, not the denial of a contributor’s standing as a peer.
Egoless programming was never about diminishing the programmer.
It was about making room for others.
The time has come to recognize that others need not be human.