Is there a fundamental limit to software developer productivity?

Legacy code is a concern for any company with a reasonably size team pretty quickly. In this article Wayne Lobb from Foliage provides us with industry metrics with respect to code growth (Unfortunately need to register to download). The quick summary is that on average a developer can either create 10K lines of code per year *OR* maintain 50K lines of code. In other words, within a few years a developer is choked maintaining his own work... Wayne Lobb's industry metrics started me thinking: How does developer productivity declines over time? After a bit of math Wayne's metrics imply the following equation: 1) $\Large P(t) = P_0 * e^{-rt}$ In this equation $P_0$ is the developer productivity without any legacy obligation. $r$ is the constant rate of productivity decline as a result of the amount of code present. To estimate average SW developer productivity in year $t$ we get: 2) $\Large P(t) = 11.16 * e^{-0.22 * t}$

var board = JXG.JSXGraph.initBoard('box', {boundingbox: [-2, 20, 25, -5], keepaspectratio:true, axis:true});

var s = board.create('slider', [[-1,0],[-1,20], [0,11.15,20]], {name:'s'}, {withLabel: false});
var p0 = board.create('point', [0, function(){return s.Y()}], {name:'P0', fixed:true});

var r = board.create('slider', [[0,15],[15,15], [0,2.232,15]], {name:'',withLabel:false});
var label = board.create('text',[function() {return 17},function() {return 15},function(){ return ("r = " + (r.X()/10.0).toFixed(3)) }]);

var graph = board.create('functiongraph',
[function(x){ return p0.Y() * Math.exp(-(r.X()/10.0) * x);}, 0.0, 20.0, {strokeWidth:4}]
);
var integral = board. create ('integral', [[function() {return 0.0}, 1.0], graph], {fillColor:'lightGreen'});

board.update();
With such an exponential 'brake' on each developers productivity it is no wonder that many companies find themselves into maintenance issues quickly and get into the "we need a redesign" dilemma so brilliantly depicted by Uncle Bob Martin in Episode one of his CleanCoders episodes. (Be sure to purchase your copies, the videos are really good...)
Download Video Bob Martin suggest that our way out of the productivity trap is by 'clean code' and by clean code 'alone'. Certainly i agree that 'clean code' and continuous refactoring will lead to a lower productivity decline and thus a lower value for $r$. But there seems to be a more fundamental, easier overlooked, reason why we slow down: our own legacy... The formula seems to explain, at least partly, the following observations: * Why new teams seem more productive in the start * Why outsourcing/contracting attractive (the new team does not have legacy) Most software estimation models i know assume that developer productivity is constant over time. But based on this analysis, constant productivity seems very unlikely if the team size stays the same. In a 3 year project, the production in year 3 is roughly 30% lower than in the first year. What do you think? Where are the limits of an individual software productivity? Is there a maximum lines of code a single developer can maintain? Are Wayne's industry metrics recognisable to you? Is my analysis and formula credible?