Ballmer Rebukes IBM Policy Tying OS/2 Payouts to Lines of Code
Ali Gajani
Tying developer compensation to raw code volume penalized engineering excellence by reducing payouts when developers created faster, more compact software, Steve Ballmer says.
AI-assisted summary of Steve Balmer on KLOCs — original source. Check the original for full context.
Source published:
Key ideas
- IBM historically relied on "KLOCs" (thousands of lines of code) as its core metric to scope software projects and assess engineering productivity. (0:00)
- During the joint development of OS/2, IBM attempted to base financial compensation and revenue sharing on the volume of code produced. (0:00)
- Steve Ballmer argued the model penalized engineering excellence, noting that an efficient 4 KLOC solution would be paid less than a bloated 20 KLOC implementation. (0:00)
- Reflecting on IBM's dogmatic approach, Ballmer described the experience with visceral discomfort, remarking that the memory still made his back crinkle up. (0:00)
Detailed notes
## Background Published on YouTube by Ali Gajani on November 27, 2014, this brief clip captures former Microsoft CEO Steve Ballmer reflecting on software metrics. The video does not include any accompanying show notes or description.
## TL;DR Steve Ballmer recounts IBM's dogmatic insistence on measuring software projects and developer output by "KLOCs," or thousands of lines of code. During the joint development of OS/2, IBM wanted to determine compensation strictly based on the volume of code produced. Ballmer challenged this metric, arguing that it unfairly penalized engineering excellence by paying less for a fast, elegant 4-KLOC solution than for bloated 20-KLOC code. He highlights the profound friction between IBM's bureaucratic methodology and Microsoft's focus on software efficiency.
## Atmosphere & style The clip features a candid, animated, and exasperated reminiscence from Steve Ballmer as he revisits a legendary corporate culture clash. His tone moves from disbelief to visceral frustration as he recounts IBM's rigid mindset, punctuated by his physical shudder at the memory of the ordeal. Watching the segment feels punchy and revealing, offering an authentic, unfiltered glimpse into the friction between legacy enterprise bureaucracy and modern software development.
## Bulletin - [00:00](https://www.youtube.com/watch?v=kHI7RTKhlz0&t=0s) IBM historically relied on "KLOCs" (thousands of lines of code) as its core metric to scope software projects and assess engineering productivity. - [00:00](https://www.youtube.com/watch?v=kHI7RTKhlz0&t=0s) During the joint development of OS/2, IBM attempted to base financial compensation and revenue sharing on the volume of code produced. - [00:00](https://www.youtube.com/watch?v=kHI7RTKhlz0&t=0s) Steve Ballmer argued the model penalized engineering excellence, noting that an efficient 4 KLOC solution would be paid less than a bloated 20 KLOC implementation. - [00:00](https://www.youtube.com/watch?v=kHI7RTKhlz0&t=0s) Reflecting on IBM's dogmatic approach, Ballmer described the experience with visceral discomfort, remarking that the memory still made his back crinkle up.
## Key takeaways - [00:00](https://www.youtube.com/watch?v=kHI7RTKhlz0&t=0s) IBM treated KLOCs (thousands of lines of code) as an institutional standard for quantifying software engineering productivity. - [00:00](https://www.youtube.com/watch?v=kHI7RTKhlz0&t=0s) Project scoping at IBM was rigidly categorized by code volume, labeling initiatives as 10 KLOC, 20 KLOC, or 50 KLOC projects. - [00:00](https://www.youtube.com/watch?v=kHI7RTKhlz0&t=0s) IBM attempted to enforce the KLOC metric to dictate developer compensation and revenue distribution during the OS/2 project with Microsoft. - [00:00](https://www.youtube.com/watch?v=kHI7RTKhlz0&t=0s) Steve Ballmer argued that tying compensation to code volume created a perverse incentive against software optimization and conciseness. - [00:00](https://www.youtube.com/watch?v=kHI7RTKhlz0&t=0s) Under IBM's compensation framework, writing an elegant 4 KLOC solution earned less revenue than delivering a 20 KLOC implementation. - [00:00](https://www.youtube.com/watch?v=kHI7RTKhlz0&t=0s) Microsoft emphasized that concise codebases should be rewarded, as smaller implementations typically result in faster and more efficient software. - [00:00](https://www.youtube.com/watch?v=kHI7RTKhlz0&t=0s) IBM remained inflexible in its methodology, insisting that tracking KLOCs was the proper way to govern software production. - [00:00](https://www.youtube.com/watch?v=kHI7RTKhlz0&t=0s) The dispute over KLOCs highlighted a fundamental cultural and engineering divide between IBM and Microsoft during their collaboration. - [00:00](https://www.youtube.com/watch?v=kHI7RTKhlz0&t=0s) Ballmer recalled the absurdity of the KLOC system with physical discomfort, noting it still made his back "crinkle up."
## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=kHI7RTKhlz0&t=0s) The IBM Religion of Measuring Software by KLOCs
Steve Ballmer recalls the corporate culture and software engineering environment at IBM, describing a rigid mindset centered around measuring developer productivity through "KLOCs"—an industry shorthand for a thousand lines of code. In IBM's view at the time, project scoping was defined entirely by this single metric: managers would categorize an initiative by asking whether it was a 10 KLOC project, a 20 KLOC project, or a massive 50 KLOC effort. IBM attempted to impose this dogma directly onto their business relationship with Microsoft, treating lines of code as the primary mechanism to dictate compensation and determine who made how much money during the joint development of OS/2.
Ballmer details the fundamental friction this caused between the two companies, as Microsoft argued that incentivizing raw volume directly penalized engineering excellence and optimization. If an engineer devised a clever, elegant approach that solved a problem in 4 KLOC instead of 20 KLOC, Ballmer questioned why Microsoft should earn less revenue simply because the developer created software that was smaller, faster, and more efficient. IBM remained unyielding, dogmatically insisting that tracking KLOCs was the required methodology. Reflecting on the sheer absurdity and frustration of the arrangement, Ballmer remarks with visible discomfort: “Anyway, almost makes my my back just crinkle up at the thought of the whole thing.”
- **Definition of a KLOC**: A measurement denoting one thousand lines of code (KLOC), used by IBM as a standard metric to categorize the scope of software projects (e.g., 10 KLOC, 20 KLOC, or 50 KLOC). - **Dispute over OS/2 Compensation**: IBM wanted to tie financial compensation and revenue sharing on OS/2 directly to the quantity of code produced rather than software functionality, performance, or quality. - **The Efficiency Penalty**: Ballmer argued against the methodology by pointing out that a skilled engineer writing a 4 KLOC solution instead of a bloated 20 KLOC implementation would unfairly earn less money despite producing smaller, faster, and superior code.
## Mentioned Steve Ballmer, IBM, Microsoft, OS/2, Ali Gajani
[Source](https://www.youtube.com/watch?v=kHI7RTKhlz0)