Isn't this falling into the "lines of code" trap TFA mentions?
More code written is not a good measure of productivity. It could be garbage, or redundant code, or simply not addressing the real or more pressing needs, it could be building the wrong thing, etc.
Like TFA mentions, it's been known for decades LoC is a misleading metric for productivity. It's one of the lessons of software engineering.
I'm planning an article at the moment in defense of lines of code. Saying "lines of code are a bad measurement" is too easy! It's about time someone presented an opposing argument.
In my specific case, lines of code for my published open source projects is a metric that I trust, because I have high standards for those. I have plenty of other projects where I'll accept poor quality, unreviewed code (almost all of https://github.com/simonw/tools for example), but Datasette, sqlite-utils and LLM are not that.
Of course, that's only useful for me personally and for people who trust me to stick to my own self-declared high standards!
> Saying "lines of code are a bad measurement" is too easy! It's about time someone presented an opposing argument.
Maybe because there is none.
One of the main quality of good codebase is simplicity. Which is about how easy for someone else to understand the code. It’s hard to define what simplicity looks like, so the best bet is to avoid the other side, making the code too complex.
And you can make the code complex by shortening variable name, doing code golfing with quicks of the platforms, so smaller LoC. You can also go the other way and increase the LoC by adding unneeded abstractions, repeating slices of code,… There’s a window where the LoC is perfect to attain simplicity, but that amount is an effect of striving for simplicity, not a cause of it. And it’s variable for every problem.
So you got something where the correct value is a different for each case. And trying to manipulate it artificially often results in complex code. And you want to say that is a good metric for productivity?
And in the cases of your projects, there are a lot more info could share that are interesting, like the amount of issues (reported or found by you) that are tied to implementation bugs (coding, libraries API breakage,…) or design issues (requirements conflicts,…), documentation improvement,… Anything that is tied to the actual usefulness of the projects, and not fumbling around with code.
> Saying "lines of code are a bad measurement" is too easy! It's about time someone presented an opposing argument.
I don't know about easy. It's a hard earned lesson of software engineering, backed by research (some of it cited in TFA). Also, there's a related lesson: the more LoC to solve a given problem, the more bugs. That's also a finding backed by research.
I'll be reading your article when you write it, but I confess I'm skeptical.
The AI companies have a vested interest in using this metric, since it's easy to measure (the reason LoC were used even before AI) and there's no doubt that LLMs are writing tons of code. This makes me doubly skeptical.
> Saying "lines of code are a bad measurement" is too easy! It's about time someone presented an opposing argument.
Why though? The only entities who would be interested in such an implication is the AI marketing.
No one real cares about more or less lines of code. But everyone cares about decreasing the complexity of the implementation. Sometimes that means more LOC and sometimes it means less.
> Lines of code are akshually a good metric now, because that's the only metric LLMs can optimize and I really, really, really love LLMs, they're the bee's knees.
The article mentions that coding is only a fraction of dev time and thus accelerating that part of the job can only create incremental gains, and oh PS, lines of code and similar metrics are a bad way if measuring dev productivity, anyway, and we've known that for decades.
The OP claims AI accelerates non-coding parts of the job, too, and so the article is misguided.
That's why Microsoft did a study (referenced in the article), where they measured the time spent on things, so they could get to the truth of how much time people spend coding using "a shape of evidence would you find convincing"
The Microsoft study concerns the ideal vs. actual developer workweek. They conclude that developers using AI tools "heavily" are both more productive and more satisfied. And, surprise, that devs hate meetings and want to code more.
