Software engineering, checked · Part 10 of 13
People: the 28:1 legend
In 1968, Sackman, Erikson and Grant published an experiment about machines. Time-sharing was new, and the question was whether programmers worked faster at an online terminal or by submitting their jobs offline and waiting for the results. They gave twelve experienced programmers two debugging tasks and measured how long they took.
The machines turned out to be the smaller story. "Perhaps the most important practical finding," the authors wrote, "involves the striking individual differences in programmer performance." On one measure, the best programmer was 28 times faster than the worst. The ratio left the paper, lost its context and kept travelling. Retold for half a century, it settled into one of the field's most durable beliefs: the 10x programmer, the engineer worth ten ordinary ones.
This part is about the people who write the software. The question is plain: how different are programmers really, and what actually helps them do good work?
Where does 28:1 come from?
Look at what the 28 compares. Twelve people is a small sample, and the ratio sets the single best against the single worst, the two points most likely to be flukes. The participants also worked under different conditions, some online and some offline, so the extremes mixed people with conditions. In 1981, a letter by Dickey put it bluntly: "Existing citations of the Sackman programming research are in error." ~15 %
That doesn't make programmers interchangeable. The same year, Bill Curtis presented another data set that, in his words, "substantiates the enormous variability in programmer performance." The useful question is how big the differences are when the comparison is fair.
Lutz Prechelt's comparison of 80 implementations of the same program, in seven languages, gives one answer. Instead of best against worst, he compared the slower half of the programmers with the faster half. Depending on the language, the slower half took between 1.5 and 3.2 times as long. Real, and nowhere near 28. Prechelt also found that differences between programmers using the same language were about as large as, or larger than, the differences between languages ~70 %. Who writes the program matters at least as much as what it's written in, though with one small task the size of that gap is uncertain.
Ten times what?
The 10x programmer is the 28:1 rounded to a friendlier number, and it has the same weakness. Tenfold gaps appear when you compare the extremes on a single task. They shrink when you follow the same people across many tasks ~30 %.
Nichols did exactly that, with personal software process data from hundreds of programmers who recorded their own work task by task. Much of the spread turned out to be within each programmer rather than between them: the same person was quick on one task and slow on the next. His paper is titled The End to the Myth of Individual Programmer Productivity, and its conclusion is carefully worded: "it would appear that some programmers are not inherently exceedingly better than others."
The belief is about people: some are simply better. What gets measured is mostly a task: this problem, this day, this codebase. Programmers do differ. But a ranking based on one task says a good deal about the task.
Years are not experience
If ability isn't fixed, perhaps it accumulates. Job adverts assume so: five years of this, ten of that. Dieste and colleagues tested the idea across ten quasi-experiments with students and professionals, and their conclusion was blunt: "Programming experience gained in industry does not appear to have any effect whatsoever on quality and productivity." ~30 %
Other kinds of experience do show up. In Linux and PostgreSQL, the more experienced the developer, the less likely their commits were to be buggy. In a large field study, senior developers spent a smaller share of their time on program comprehension than juniors. The difference is between years on a CV and familiarity with the work in front of you: this codebase, its history, its traps. The first is easy to count. The second is what helps.
Nor does age wear the knowledge away. On Stack Overflow, reputation keeps rising with age well into developers' fifties, and age barely relates to scores in specific knowledge areas ~15 %. The data is observational, and people answering questions on Stack Overflow at 55 are not a random sample of 55-year-olds, but it points the opposite way from the folklore.
The camel and the two humps
The 10x programmer has a classroom cousin: the belief that programming is something you can either do or you can't. An unpublished 2006 paper called The camel has two humps claimed that a simple test, taken before the first lesson, could tell who would learn to program. Students who answered its questions consistently were supposed to do well. Lung and colleagues repeated it with students at the University of Toronto and found that "being consistent has no significant correlation with being above or below the median at the end of the course." The test's author retracted the claim in 2014 ~5 %.
Behind the camel sits an older piece of teaching lore: grades in programming courses have two humps, the students who get it and the ones who never will. Patitsas and colleagues analysed 778 distributions of final course grades from a large research university. Only 5.8% passed statistical tests of multimodality. They also asked 53 computer science professors about grade distributions. Professors were more likely to see two humps when they had been primed to expect them, and when they believed ability is innate. The authors call bimodal grades "instructional folklore", caused by confirmation bias and instructors' beliefs about their students ~15 %. The belief shaped what people saw in the data, which is the series' third thread in its purest form.
Where the week goes
Ask what programmers do all day and the folklore says: write code. In a 2025 survey of 484 Microsoft developers, coding took about 11% of the week, debugging about 9%, and communication and meetings about 12%, the largest single share. The developers said they would like to spend about twice as much time coding ~85 %. Software is people talking, and in a developer's week it's measurable. When researchers observed 20 professionals over about eleven workdays each, the days were fragmented across many activities, with constant switching between them.
Much of the rest is reading. Xia and colleagues recorded 3,148 working hours of 78 professional developers. About 58% went on program comprehension, 24% on navigation and 5% on editing ~85 %. Comprehension here includes reading documentation and debugging, not only reading source, but the old saying that code is read ten times more than it is written holds up.
What makes a good day? In nearly 6,000 responses from Microsoft developers, the key finding was agency: control over the workday, and whether it went as planned or was disrupted by others ~70 %. In an earlier study, developers said their days felt productive when they finished tasks without significant interruptions or context switches. Yet the developers who were observed switched tasks constantly and still felt productive.
Interruptions carry their own famous number: 23 minutes to get back on track. It isn't in the study usually cited for it. That study, by Gloria Mark and colleagues, found that interrupted people completed their tasks faster, with no difference in quality ~30 %. Programmers may be a harder case. In 10,000 recorded sessions of 86 programmers, only 10% resumed editing within a minute of an interruption, and in about 30% the lag was over half an hour ~70 %. The popular "10 to 15 minutes" is a rough summary, not a measured average. ### Watched, tired and up late
The standard technical interview puts a candidate at a whiteboard, solving a puzzle while an interviewer watches. Behroozi and colleagues tested what the watching does. They randomly assigned 48 computer science students to solve a problem either in front of an interviewer or alone. Being watched cut performance by more than half ~70 %. No woman solved the problem in the public setting; every woman in the private setting did. The numbers are small and students are not job candidates, but the effect is too large to wave away. Developers on Hacker News describe it from the other side: unnecessary anxiety and arbitrary, implicit norms.
A whiteboard interview, in other words, partly measures how someone copes with an audience. Other states show up in the work too. In a study of 42 participants, those in a better mood scored higher on analytical problem solving, though not on creativity ~70 %. In a quasi-experiment with 45 undergraduates, a single night without sleep cut the quality of their implementations by half ~70 %. It wasn't randomised, the participants were students, and there was one task.
Commit histories point the same way. In Linux and PostgreSQL, commits made between midnight and 4 AM were significantly buggier, and those made between 7 AM and noon less buggy ~70 %. Two projects and a correlation: the people committing at 3 AM may also be the ones fixing emergencies.
Counting the wrong thing
If programmers differ, managers want to know by how much, and the oldest answer is to count lines of code. Google's developer productivity researchers call that "clearly fraught" ~15 %. Lines measure activity, not value, and a good change can delete code. Their larger point is that no single metric captures productivity, and that hunting for one is counter-productive. The SPACE framework, from researchers behind the DORA metrics, makes the same case: productivity has several dimensions that need measuring together ~70 %. It is an expert framework rather than a tested model, and its activity dimension is the easiest to game.
Crunch is the same mistake applied to hours. A study of game development postmortems and interviews found four kinds of unpaid overtime. Only one had purely positive effects on product and schedule, all four raised stress, and crunch was rarer where features were prioritised ~30 %.
So what does go with productivity? Across 622 developers at three companies, the strongest correlates of self-rated productivity were non-technical: job enthusiasm, peer support for new ideas, and useful feedback about their work ~70 %. It is self-rated and correlational, and it fits the rest of this part. Sackman went looking for the effect of a machine and found people. Fifty years on, people are still the larger effect, just not the way the 28:1 suggests: less about who is a genius, more about who is watching, how long they slept and whether their day is their own.
What doesn't work
- Quoting 28:1 or the 10x programmer. The 28 compared the extremes of a dozen people under mixed conditions; fairer comparisons give 1.5 to 3 ~15 %.
- Hiring on years of experience. Across ten quasi-experiments, years in industry predicted neither quality nor productivity ~30 %.
- Sorting learners by aptitude. The camel test failed to replicate and was retracted ~5 %, and the two humps in the grades are mostly in the eye of the beholder.
- Counting lines of code. It measures activity, misses most of the work and punishes deleting code ~15 %.
- Crunch as a plan. Most kinds of crunch didn't help the product or the schedule, and all of them raised stress ~30 %.
Try this
- Check the conditions before judging the person. Much of the spread in performance is within each programmer. When someone looks slow, look at the task, the codebase and the interruptions first.
- Interview without an audience. Let candidates work on a problem alone first, then talk it through with them.
- Value familiarity over years. Knowing a codebase helps; years on a CV don't. Count the cost of moving people off code they know.
- Give developers their day. Good days are the ones developers control. Guard long stretches during development, and expect each interruption to cost more than the moment it takes.
- Leave the 3 AM merge until morning. Late-night and sleep-deprived work is where the bugs are; review it twice or ship it after breakfast.
20 claims checked
The evidence behind this article
Every claim above, rated by the chance it holds up against the research. Open one for the sources and their exact words.
- Behroozi, Parnin, Barik (2019). Hiring is Broken: What Do Developers Say About Technical Interviews? · Study
- Behroozi, Shirolkar, Barik, Parnin (2020). Does stress impact technical interview performance? · Study
- Curtis (1981). Substantiating programmer variability · Study
- Dickey (1981). Programmer variability · Source
- Dieste, Aranda, Uyaguari, Turhan, Tosun, Fucci, Oivo, Juristo (2017). Empirical evaluation of the effects of experience on code quality and programmer productivity: an exploratory study · Study
- Edholm, Lidstrom, Steghofer, Burden (2017). Crunch Time: The Reasons and Effects of Unpaid Overtime in the Games Industry · Study
- Eyolfson, Tan, Lam (2011). Do time of day and developer experience affect commit bugginess? · Study
- Forsgren, Storey, Maddila, Zimmermann, Houck, Butler (2021). The SPACE of Developer Productivity · Source
- Fucci, Scanniello, Romano, Juristo (2018). Need for Sleep: The Impact of a Night of Sleep Deprivation on Novice Developers’ Performance · Study
- Graziotin, Wang, Abrahamsson (2014). Happy software developers solve problems better: psychological measurements in empirical software engineering · Study
- Jaspan, Sadowski (2019). No Single Metric Captures Productivity · Source
- Lung, Aranda, Easterbrook, Wilson (2008). On the difficulty of replicating human subjects studies in software engineering · Replication
- Mark, Gudith, Klocke (2008). The cost of interrupted work · Study
- Meyer, Barr, Bird, Zimmermann (2021). Today Was a Good Day: The Daily Life of Software Developers · Study
- Meyer, Barton, Murphy, Zimmermann, Fritz (2017). The Work Life of Developers: Activities, Switches and Perceived Productivity · Study
- Meyer, Fritz, Murphy, Zimmermann (2014). Software developers' perceptions of productivity · Study
- Morrison, Murphy-Hill (2013). Is programming knowledge related to age? An exploration of stack overflow · Study
- Murphy-Hill, Jaspan, Sadowski, Shepherd, Phillips, Winter, Knight, Smith, Jorde (2021). What Predicts Software Developers’ Productivity? · Study
- Nichols (2019). The End to the Myth of Individual Programmer Productivity · Study
- Parnin, Rugaber (2010). Resumption strategies for interrupted programming tasks · Study
- Patitsas, Berlin, Craig, Easterbrook (2016). Evidence That Computer Science Grades Are Not Bimodal · Study
- Prechelt (2000). An empirical comparison of seven programming languages · Study
- Sackman, Erikson, Grant (1968). Exploratory experimental studies comparing online and offline programming performance · Study
- Sukrit, Goel, Zimmermann, Houck, Ashok, Chetan (2025). Time Warp: The Gap Between Developers' Ideal vs Actual Workweeks in an AI-Driven Era · Study
- Xia, Bao, Lo, Xing, Hassan, Li (2018). Measuring Program Comprehension: A Large-Scale Field Study with Professionals · Study