1. Understand and accept that you will make mistakes.

    No one writes perfect code. Bugs, oversights, and misjudgments happen to everyone, including experts. The key is to treat mistakes as opportunities to learn rather than sources of embarrassment. An egoless programmer fixes issues calmly, analyzes why they happened, and improves their process instead of defending errors.

    Example: When a bug is found during testing, thank the person who caught it instead of feeling attacked.

  2. You are not your code.

    Code reviews exist to improve the product, not to judge the programmer. The goal is to find bugs, catch design flaws, and ensure consistency — not to criticize someone’s abilities. When your code is reviewed, remember it’s a normal, expected part of building reliable software. Feedback is about making the code better together, not about you being wrong.

    Example: Think, “We’re finding issues in the code so it’s stronger,” not “They’re finding faults in me.”

  3. No matter how much “karate” you know, someone else will always know more.

    There’s always a more experienced or specialized developer out there. Recognizing this keeps you humble and open to learning. Instead of competing for superiority, treat discussions as chances to improve together. Curiosity will make you a better programmer than pride ever could.

  4. Don’t rewrite code without consultation.

    Even if existing code looks inefficient or messy, consult the team before reworking it. There’s a fine line between fixing code and rewriting it — know the difference. Pursue changes as part of a code review, not as a lone enforcer. Unilateral rewrites can waste time, break dependencies, or erase important context.

    Example: Before refactoring a module, talk to the original author to understand the decisions and constraints behind it.

  5. Treat people who know less than you with respect, deference, and patience.

    Mentorship builds stronger teams. Talking down to less experienced developers discourages them and weakens collaboration. Share knowledge with patience and humility — remember, you were once a beginner too. Nontechnical colleagues often see developers as prima donnas or overly sensitive; don’t reinforce that stereotype with anger or impatience. The way you treat newcomers and teammates sets the tone for your team’s culture and reputation.

  6. The only constant in the world is change.

    Technology evolves quickly—languages, frameworks, and best practices constantly shift. Adaptability is more important than mastery of a single tool. Be ready to learn new approaches and let go of old habits.

    Example: Moving from monoliths to microservices, or from manual deployments to CI/CD pipelines, requires flexibility.

  7. The only true authority stems from knowledge, not from position.

    Titles and hierarchy shouldn’t override logic or facts. In a healthy engineering culture, ideas win on merit, not on who said them. Leaders should earn respect through understanding and clear reasoning, not through formal rank.

  8. Fight for what you believe, but gracefully accept defeat.

    If you think something is important, advocate for it with evidence and conviction. But once the team decides, support the outcome even if it wasn’t your proposal. This balance between assertiveness and teamwork builds trust and keeps projects moving forward.

  9. Don’t be “the guy in the room.”

    This means don’t act like you’re smarter than everyone else. The “guy in the room” (or “hero programmer”) dominates conversations, dismisses others, and resists compromise. Avoid that behavior; it alienates teammates and stifles creativity. Good programmers make the entire team better, not just themselves.

  10. Critique code instead of people – be kind to the coder, not to the code.

    When reviewing code, focus on improving it, not judging the person behind it. Tone matters: say “This function could be clearer if…” rather than “You didn’t write this well.” Constructive feedback builds confidence and shared understanding.

(The Psychology of Computer Programming by Gerald M. Weinberg, describes principles for healthy, collaborative software development that values humility, learning, and teamwork over ego or rivalry.)