I've developed software professionally for the past 10 years. Here's a list of 100 things I've learned about software developer productivity.

1. At the beginning of your career, learning to "code fast" significantly impacts your productivity. Once you're "good enough," the impact substantially diminishes. Pay attention to when this happens.

2. Don't be too proud to try and" hack your mind." Many productivity tips that sound patronizing actually work.

3. Write your tasks down and use a to-do list.

4. Having a tangible goal will make you move faster.

5. Procastination is normal. Start by writing a single line.

6. What works for someone else might not work for you.

7. Try Pomodoro. It might work for you.

8. Learn what makes you productive.

9. Set boundaries that enable you to work in a way that makes you productive.

10. Strong intrinsic motivation and curiosity trumps all productivity hacks.

11. Learn how to tap into your intrinsic motivation. 

12. Pair program and watch other people code. You might pick up a skill or two that help you work faster.

13. Your intuition affects your productivity more than you know. Pay attention to cultivating a good intuition.

14. Learning out of a bad habit takes work. Invest in learning good habits.

15. Saying "yes" to everything will destroy your productivity. You need a personal WIP limit.

16. Being obsessed about your work will make you temporarily more productive but burn you out if stretched for too long.

17. Physical exercise, eating healthy, and sleeping well do not take away, but contribute to your productivity.

18. Take regular breaks (e.g., 10 minutes every 50 minutes). 

19. Trying to work in too long stretches will teach your brain to start wandering off to memes and hot takes on Twitter.

20. Make sure you have enough focus time for deep work and "flow." 

21. Disable all the notifications you can.

22. Being in "flow" makes you feel productive but does not always mean you're making progress.

23. You can spend hours polishing an abstraction but deliver zero customer and business value.

24. Being productive does not mean you're making an impact. Work hard on things that matter.

25. The more experience I get, the more I'm interested in improving how my team or organization works together vs. optimizing my individual productivity.

26. When solving technical problems that require collaboration, the bottleneck for individual developer productivity is not your ability to write code but the team's ability to create viable solutions.

27. Most problems in building great software products require collaboration. Your ability to collaborate will become a bottleneck.

28. You will be more productive in some teams/companies than others.

29. Eventually, the bottleneck for your productivity will be the team and organization surrounding you.

30. Developer productivity and compensation don't often go hand in hand.

31. Some companies will compensate you more for the same work than others.

32. The best "10x engineers" are the ones who 10x the team and people working around them.

33. Delegate and help other people. Learn to celebrate their success.

34. Learn to use automation. Removing errors and reducing cognitive load has a more significant impact on your productivity than "working faster."

35. Developer experience and ergonomics matter.

36. Automatically format your code with a deterministic code formatter like Prettier or Black.

37. Use a linter. Learn how to write custom rules to match the way your team works.

38. Write automated tests. Life is too short for constantly fixing trivial bugs.

39. Setting up a Continuous Integration (CI) pipeline is likely easier than you think. Learning how to do it will save you time in every future software project.

40. Keep feedback loops fast.

41. Automatically deploy to production.

42. Keep your build times low.

43. Make sure developers can run the test suite on their computers.

44. Enable automatically running related tests on file changes.

45. Use feature flags to allow shipping work faster to production.

46. You might not need a staging environment.

47. You might benefit from a staging environment.

48. It depends.

49. Developers using Vim look like they're much more productive than the rest.

50. Don't always pick the tasks that make you feel most productive. It will stagnate your learning and make you feel that you're not moving forward.

51. Prioritize reviewing code. It will help your team stay productive.

52. Every time a developer prioritizes reviewing code, a new star is born in the Torvalds & Carmack galaxy.

53. Being "agile" has very little practical meaning.

54. Calculating velocity and story points rarely help teams improve their productivity.

55. Small, practical change based on data trump "agile transformation."

56. The goal of planning is to split the elephant into bite-sized pieces.

57. Developers often prefer working alone on large tasks for long periods.

58. Developers working alone on large tasks for long periods rarely result in the smallest possible increment being shipped fast.

59. Working together on a task is often less productive in the short run.

60. Working together on a task improves learning and is often more productive in the long run.

61. With large codebases, developer productivity largely depends on their knowledge of the system.

62. Splitting large codebases into modules helps new developers become productive faster.

63. Modular architecture only works if the API contracts are clear and modules are truly decoupled from each other.

64. Sometimes, a developer is more productive than others only because they have more knowledge and power.

65. A single developer owning a disproportionate amount of knowledge and power in a team will lead to some developers underperforming.

66. A "10x engineer" born out of owning a disproportionate amount of knowledge and power is an anti-pattern and will lead to capable developers leaving your company. Avoid it at all costs.

67. Measuring developer productivity only through activity (e.g. # of commits or PR reviews) does not work.

68. Trying to condense developer productivity into a single metric will fail and make developers lose their trust in the company's management.

69. Measuring individual developer productivity is hard. If you try to do that, you will likely lose more than gain.

70. When trying to measure developer productivity, data quality is crucial. Bad decisions made based on poor data are costly.

71. There is much more reliable research on software developer productivity than most developers realize.

72. Focusing on team and organizational level developer productivity will yield the best results.

73. Reading the book "Accelerate" and understanding the SPACE framework will give you a good start to understanding development team productivity.

74. When measuring developer productivity, you should have multiple metrics that complement and challenge each other.

75. The subjective experience of developers is valuable data.

76. Only relying on the subjective experience of developers is not enough. Especially when trying to improve development productivity across the organization.

77. Improving software team productivity is largely about trying to improve the flow of work while keeping quality high and working at a sustainable pace.

78. Measuring your team's cycle time and deployment frequency will help you improve your flow of work.

79. Knowing how much time your team spends fixing bugs vs. feature work will help you prioritize writing tests, fix technical debt, and keep your quality high.

80. Developing software is a marathon, not a sprint. Optimize accordingly.

81. Teams should be in charge of improving their own productivity and have access to the necessary metrics and tools.

82. Individual developers benefit from understanding what affects their teams' overall productivity.

83. Most teams try to do too many things at the same time. You need a WIP limit.

84. WIP limits improve collaboration and help you ship the most important stuff.

85. WIP limits reduce procrastination on hard tasks.

86. WIP limits combined with good prioritization help individual developers work on things they're not familiar with and encourage learning.

87. Encouraging learning makes software developers more productive in the long run.

88. Consistently good work is better than heroics.

89. Organizations that put heroism above consistently good work perform worse in the long run.

90. Developers love to measure everything else but their own productivity.

91. Early attempts at measuring software developer productivity ruined the whole thing for most developers.

92. It is hard to recover from industry trauma.

93. Don't focus on measuring individual developers if you're trying to improve your company's software development speed.

94. Learning about Lean and Queuing theory is valuable when improving software team productivity.

95. Consultants have done a great job ruining Lean for the rest of us.

96. Measuring software team productivity can make engineering teams happier.

97. Measuring software team productivity only makes teams happier and more productive if they're on board.

98. If developers are not on board, your metrics will be gamed.

99. Not giving your developers proper autonomy and control over their work will make them unhappy. Do not micromanage.

100. Happy engineers are more productive.

See and share on Twitter

You can see these tips in Twitter thread here: