Companies such as Google have billions at their disposal yet still can’t figure out simple project management?

Google of the past is no more, unfortunately.

Trust me I tried many many times.

This has nothing to do with Google being evil it’s just one of the realities of maintaining a big open source project.

Open Source projects are typically done by people who like coding. Writing docs, reviewing PRs, "management" are all chores, not fun parts of the project.

I manage a couple of projects that get submissions. Handling that is really not the fun part of my day. Fortunately I get very few. I can understand why ones that get a lot see it as a burden, not as the great gift the submitter thinks it is.

Personally I don't want to spend hours each day reviewing PRs. That's not what I signed up for.

Nonmatching styles can be mostly solved with linting and static analysis

There’s no fix for bad code outside of manual review beyond that. But doing those things should significantly cut down on your noise.

90% of contributors won’t read it at all or only some parts of it and ignore the rest.

Most PRs you get solve some super specific individual problem and aren’t relevant for the wider community that uses your OSS.

It’s not their fault really but most contributions are so bad it doesn’t serve to spend any time on reviewing them earnestly.

(Been maintaining several popular projects for the last 7 years)

Edit: https://judahmeek.com/p/we-need-frogs-to-defend-foss may be the better link to start with.

In my case there is a monetised proprietary “enterprise” edition of the projects available. Contributions only get accepted if they fit into the commercial roadmap, which is shaped by the (paying) customer needs.

It’s not perfect but the OSS “community” edition is still usable and valuable to many

Examples, calculating something twice instead of pulling the calculation out of the loop (one case) or into a separate function so that 2 separated places where it's calculated don't get out of sync (a different case). Another might be using an let x; if (cond) x = v1 else x = v2 (which is 3-9 lines depending on your brace style) vs const x = cond ? v1 : v2. When v1 and v2 are relatively simple expressons. I haven't seen a checker that will find stuff like this.

Only syntactical styles. Style also include things like how I want errors to be propagated, how failures are to be handled, etc.

I say almost exactly the same thing about agent changes, but the impression I get from people heavily using agents is that they are plenty more flexible about what the code looks like than I am.

I am starting to suspect that it is a personal failing of mine to require that all my code looks consistent within a single project.

Linters can't catch most things that are not syntax-style; i.e. linters can't catch semantic style.

Here is code CC generated this morning for me:

    size_t bvks_tls_read (bvks_tls_t *tls, void *dst, size_t dst_len)
    {
       int ret = wolfSSL_read (tls->ssl, dst, (int)dst_len);
    
       if (ret > 0)
          return (size_t)ret;
    
       if (ret == 0)
          return 0;
    
       // ret < 0, error case
       int err = wolfSSL_get_error (tls->ssl, ret);
       switch (err) {
          case WOLFSSL_ERROR_WANT_READ:
          case WOLFSSL_ERROR_WANT_WRITE:
             errno = EAGAIN;
             break;
          case WOLFSSL_ERROR_SYSCALL:
             // errno already set by the underlying socket call
             break;
          default:
             errno = EPROTO;
             break;
       }
       return (size_t)-1;
    }
    
    size_t bvks_tls_write (bvks_tls_t *tls, const void *src, size_t src_len)
    {
       int ret = wolfSSL_write (tls->ssl, src, (int)src_len);
    
       if (ret > 0)
          return (size_t)ret;
    
       if (ret == 0)
          return 0;
    
       // ret < 0, error case
       int err = wolfSSL_get_error (tls->ssl, ret);
       switch (err) {
          case WOLFSSL_ERROR_WANT_READ:
          case WOLFSSL_ERROR_WANT_WRITE:
             errno = EAGAIN;
             break;
          case WOLFSSL_ERROR_SYSCALL:
             // errno already set by the underlying socket call
             break;
          default:
             errno = EPROTO;
             break;
       }
       return (size_t)-1;
    }

    typedef int (tls_op_func_t) (WOLFSSL *, void *, int);
    
    static size_t tls_op (WOLFSSL *ssl, tls_op_func_t *fptr,
                          void *buf, size_t len)
    {
       if (len > INT_MAX) {
          errno = EINVAL;
          return (size_t)-1;
       }
    
       int wbytes = fptr (ssl, buf, (int)len);
       if (wbytes >= 0)
          return (size_t)wbytes;
    
       errno = map_wolf_error (wolfSSL_get_error (ssl, wbytes));
       return (size_t)-1;
    }
    
    size_t bvks_tls_read (bvks_tls_t *tls, void *dst, size_t dst_len)
    {
       return tls_op (tls->ssl, wolfSSL_read, dst, dst_len);
    }
    
    size_t bvks_tls_write (bvks_tls_t *tls, const void *src, size_t src_len)
    {
       return tls_op (tls->ssl, (tls_op_func_t *)wolfSSL_write, (void *)src, src_len);
    }

The other isolates the potentially buggy behaviour, validates it, and ensures that future changes to fix size_t/int precision loss bugs only has to be done in a single spot.

No linter is catching that style. It's more "coding style" than "syntax style".

Yes there is a lot of garbage out there, but for the people who are actually trying to fix issues it is impossible without an insider within the project.

https://github.com/google/flatbuffers/pull/8252

Flatbuffers Lua implementation has basic fundamental flaws, couldn't even get an "idc" on their Discord