Hot Take: Less Code Is More

5min Read

Recently I was successfully rage-baited by a CEO boasting:

“37K LOC per day across 5 projects…Still speeding up”

X Post

See here

I understand the evolving landscape of Agentic Engineering allows us to “move” faster than ever before.

But the question STILL remains…

”Where to?”


Even after reading his response to the community backlash here and perusing the github of the alleged project, I’m still confused on what the Product or Service or App (or Advice?) is being marketed to me.

This isn’t a bash on trendy AI.

Definitely leverage it as a tool to write better code. Code that you will be responsible for.

Reading, Maintaining, and Building upon.

Accelerating vibe-code is a recipe for slop disaster.

& unless you yourself can read and contextualize 37k lines of code per day, and still speed up, the most likely scenrario is that you are going to hit a limit on your own understanding of the codebase, just like the AI agents themselves.

Now nobody knows!


Regardless, I stand firm in believing that generally:

“Less Code is More”

With less code (again, generally):

  • Your app is more accessibile to Users (faster load times) 1, 2
  • Testing becomes easier
  • Production issues are quicker to diagnose and resolve
  • Design and architecture becomes clearer
  • Build and deployment times are reduced
  • Less resource usage ($$$) (AI, Hosting, Networking)
  • Less mental fatigue for developers & agents leading to faster feature delivery

With all those benefits there has to be a cost right?

Yup.

The cost is in keeping the code to a minimum.

yet understandable and clear.


During my last “sprint” of a hobby project, I was able to deliver new features AND increase performance while ending up with LESS code than I originally started with!

From 20,490 measely lines to 20,068.

About a ~2% code reduction. Not a lot. But…less.

How, you say?

By Refactoring. Old school style.

Specifically by leveraging: Design Patterns, DRY Principles, KISS, YAGNI, and the like.

De-bloating the code by minimizing logic through OOP (where it made sense).

The aforementioned ragebait motivated me to create a script to observe the growth of my own App’s main codebase:

git ls-files --directory src/ | grep -E '\.js|\.ts|\.svelte' | xargs wc -l

All it does is count the lines per file tracked by git and also calculates the sum of them all.

(For now I really only care about *.js, *.ts, *.svelte files)

Screenshot of LOC Script

I run it after each story I complete to see whether LOCs are up/down from before.

Spoiler Alert: Majority of the time, they’re up!

But as I mentioned earlier, that’s not always a good thing. So this file serves as another way to look out for refactoring opportunities.

& I want to stress that this is not meant to place a hard limit on lines of code, but instead, to say:

With only ~20k lines of code thus far, my app is/has:

  • An offline music player
  • Themeable
  • Crossbrowser
  • Responsive to multiple layouts
  • Custom API support for non-local music management
  • Caching enabled
  • 2d/3d visualizations
  • Partial support for viz editing

And theres still room for improvement, as always!

Til next time, Ciao…



Some Further Reading:







Footnotes

  1. An example would be removing irrelevant HTML and CSS within the codebase which increase DOM load times. ↩

  2. Although most code in production is compiled or compressed, LOC as a metric can still mean duplicated code or unused function calls are included in the distribution. ↩