C Linked List Code Style

Design

Your list includes the head of the list.

struct ll_LinkedList {
   ll_LinkedListNode* head;
};

You could make a lot of your code a lot simpler by including two other values (the tail and the length).

struct ll_LinkedList {
   ll_LinkedListNode* head;
   ll_LinkedListNode* tail;
   size_t             size;
};

This would make sure you don't have to keep calculating the size and would make appending really easy.

Code Review:

#include "ll.h"

void ll_append(ll_LinkedList* ll, void* data) {
  ll_insert(ll, ll_length(ll), data);            // doubles the cost of the insert
                                                 // you have to traverse the list
                                                 // twice.
}

What happens if pos is beyond the end?

void* ll_at(ll_LinkedList* ll, size_t pos) {
  ll_LinkedListNode* node = ll->head;
  while (pos > 0) {
    node = node->next;
    pos--;
  }
  return node->data;
}

You should validate that ll is not NULL before assigning.

ll_LinkedList* ll_create() {
  ll_LinkedList* ll = malloc(sizeof(*ll));
  ll->head = NULL;
  return ll;
}

Simplify the destroy:

void ll_destroy(ll_LinkedList* ll) {
  ll_clear(ll);
  free(ll);
}

void ll_insert(ll_LinkedList* ll, size_t pos, void* data) {

    // assuming pos is in range.    
    while (pos > 1) {
      node = node->next;
      pos--;
    }

Some repeated code you could remove from the if statement.

void* ll_remove(ll_LinkedList* ll, size_t pos) {
  if (pos == 0) {

    // STUFF
    void* data = rm->data;
    free(rm);
    return data;
  }
  else {
    // STUFF
    void* data = t->data;
    free(t);
    return data;
  }
}

For a beginner the code is neat. Most is already given by the previous, much more elaborate answer.

One thing though w.r.t. coding: C is unique in that it can use aliases, pointers to a variable/field.

For instance below current first is an alias of head and after that of a node's next. With *current = ... you can fill the original variable.

void ll_insert(ll_LinkedList* ll, size_t pos, void* data) {
  assert(ll != NULL);
  // Not needed: assert(pos <= ll_length(ll));
  
  ll_LinkedListNode** current = &ll->head;
  //while (*current != NULL && pos > 0) {
  while (*current && pos > 0) {
    current = &(*current)->next;
    --pos;
  }
  // Maybe check here that pos reached 0.
  ll_LinkedListNode* new_node = malloc(sizeof(*new_node));
  new_node->data = data;
  new_node->next = *current;
  *current = new_node;
}

As you see this gives very compact code.

ll_LinkedListNode's struct declaration could move to the .c implementation with a bit of trickery.

In an other language it is customary to hold in ll_LinkedList redundantly the list size for faster operations.

Use const when able

Functions like ll_at() and ll_length() could code with const to better convey code's usage and allow some select usages and optimizations.

// void* ll_at(ll_LinkedList* ll, size_t pos);
void* ll_at(const ll_LinkedList* ll, size_t pos);

// size_t ll_length(ll_LinkedList* ll);
size_t ll_length(const ll_LinkedList* ll);

Code looks nice, but ...

Pretty layout is work. IMO, not worth the effort/time to code and maintain versus simply using an auto-formatter. (Consider work incorporating the const idea above.)

ll_LinkedList* ll_create    (      void);
void           ll_destroy   (      ll_LinkedList* ll);

void           ll_append    (      ll_LinkedList* ll, void* data);
void*          ll_at        (const ll_LinkedList* ll, size_t pos);
void           ll_clear     (      ll_LinkedList* ll);

vs.

ll_LinkedList * ll_create(void);
void ll_destroy(ll_LinkedList *ll);
void ll_append(ll_LinkedList *ll, void *data);
void* ll_at(const ll_LinkedList *ll, size_t pos);
void ll_clear(ll_LinkedList *ll);

I'd have comments per function, so there common manual format layout is not important.

Apply

Consider an apply function, something that applies the function to every link's data. Very useful.

int ll_apply(ll_LinkedList* ll, int f(void *state, void *data), void *state) {
  ll_LinkedListNode* node = ll->head;
  while (node != NULL) {
    int retval = f(state, node->data);

    // maybe break on non-zero?
    if (retval) return retval;
        
    node = node->next;
  }
  return 0;
}

Use correct specifier with size_t

// printf("Length: %ld\n", ll_length(ll));
printf("Length: %zu\n", ll_length(ll));

Could collapse code

if (ll->head == NULL) {
  new_node->next = NULL;
  ll->head = new_node;
}
else if (pos == 0) {
  new_node->next = ll->head;
  ll->head = new_node;
}

vs

if (ll->head == NULL || pos == 0) {
  new_node->next = ll->head;
  ll->head = new_node;
}

Include trick

When the unnecessary #includes move from ll.h to ll.c, include ll.h there first:

// ll.c
#include "ll.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>

This helps verify ll.h does indeed compile on its own.

Lack of comments

IMO, the .h file deserves a fair amount of comment to let users know what the set does. Assume the user does not have access to the .c file.