i like to imagine it says

we don't use this, but if you delete it everything in this file breaks

There's one I found today that just reads "this is a fucking abortion"

I don't remember doing it, but it was almost certainly me.

I would legit love to refactor that bad boy and get >95% code coverage. Put me in, coach!

Here, I optimised it:

private function is_even(integer): 
    integer = 2;
    return True;

def is_even(num:int) -> bool:
    if x < 0:
        x = x * (-1)
    if x == 0:
        return True
    elif x == 1:
        return False
    elif x == 2:
        return True
    elif x == 3:
        return False
    elif x == 4:
        return True
    elif x == 5:
        return False
    elif x == 6:
        return True
    elif x == 7:
        return False
# ...

Yes, and it only returns, "I can't even"

also depth of blocks: if i’m more than 2 or 3 indents deep, it’s probably got a bit too much logic to it and those comments should be converted to a function name

The rule of thumb I use is how likely am I to reuse some part of this code in the future? Also readability. Sometimes I like to just wrap some code in functions to make the code look neater. Other considerations are how often will this function be called? The overhead of calling a function is tiny but if a program is used by millions, everyday for many years, it's sort of like not littering a bit to make the code a bit more inline. It is kind of nice to be able to mostly see what a piece of code does in a glance other than when it's just wasteful.

I personally go by the monocre that if it's something important, it'd be all on one file as not to lose the train of thought when debugging it.

As jumping around between files

tends to break up thought lines

also, the compiler likes it better when there's less layers

I once worked on a project doing firmware that a lot of people have likely used (printer firmware for a big-name company). One of the more trafficked functions was something like 1500 lines of "if-elseif-elseif..." with something like 13 or 14 different cases.
It did end up getting refactored to something polymorphic and based on a configuration file to cut out any unnecessary steps, but it was like that for a while before I got there, and was like that for most of the year that I was part of the project.

You're dredging up some bad memories 😅

Saw one once called something dangerously innocent like "run_validation" that turned out to be a 5K line hand built deserializer (no libraries used when then absolutely should have) with so many nested levels the editor put "expand this line?(2kb)" warnings at the end of most lines.

In the original author's defence the garbage being deserialized was an Eldritch horror. We eventually moved to JSON.

4k+ nested if statements with comments.

Yeah, just comments… with chapters…