> At some point you obviously get to the function that wouldn’t have this attribute which would be an actual implementation that’s low level.

Okay ... and what then? If I understand you correctly, you're
essentially making the "code should be self-documenting" argument.
While that's a noble aspiration, there are many properties of a
function that aren't obvious from its definition. For example, the
time and space complexity is worth documenting and isn't something you
can simply eyeball.

And as you've said, you eventually run into functions that are
"low-level". A good example of that would be the top-level API of a
library. Such an API should often be rigorously documented, even if
the rest of the program isn't, and you often have just the header with
no actual sources, so there's no way to generate documentation from
code; you have to write it.

> The documentation depends on good naming just as much as the code so there’s no motivation on my part to document the code that could be written with the attitude that it will be read more often.

Yeah well, having readable code is obviously good. Code is no absolute
replacement for documentation though. If you think such an attribute
is worth pursuing, go ahead though.