There is nothing wrong with using an LLM so long as a human takes ownership for the artefact (be that books, code etc).

I would rather the author automate the mundane and focus on conveying their ideas clearly.

As an aside, is there a Linux version for this ?

There is something wrong with it because LLMs are really not capable of writing a useful book, and this book is 100% LLM slop.

Look at this totally useless """introduction""" to C: https://github.com/ebrandi/FDD-book/blob/main/content/chapte...

First of all this is an entire book, it's 76,000 words. But look at the first nontrivial example of C after "hello world," under "Bonus learning point about C return values"

  exec_map_first_page(struct image_params *imgp)
 {
        vm_object_t object;
        vm_page_t m;
        int error;

        if (imgp->firstpage != NULL)
                exec_unmap_first_page(imgp);
                
        object = imgp->vp->v_object;
        if (object == NULL)
                return (EACCES);
 #if VM_NRESERVLEVEL > 0
        if ((object->flags & OBJ_COLORED) == 0) {
                VM_OBJECT_WLOCK(object);
                vm_object_color(object, 0);
                VM_OBJECT_WUNLOCK(object);
        }
 #endif
        error = vm_page_grab_valid_unlocked(&m, object, 0,
            VM_ALLOC_COUNT(VM_INITIAL_PAGEIN) |
            VM_ALLOC_NORMAL | VM_ALLOC_NOBUSY | VM_ALLOC_WIRED);

        if (error != VM_PAGER_OK)
                return (EIO);
        imgp->firstpage = sf_buf_alloc(m, 0);
        imgp->image_header = (char *)sf_buf_kva(imgp->firstpage);

        return (0);
 }

Edit: I mean look at the intro to for loops. This is supposed to be for total beginners. Example 1:

  for (int i = 0; i < 10; i++) {
     printf("%d\n", i);
   }

>> Repeat while i < 10

>> Increment i each time by 1 (i++)

Example 2:

  for (i = 0; n > 0 && i < IFLIB_MAX_RX_REFRESH; n--, i++) {
     struct netmap_slot *slot = &ring->slot[nm_i];
     uint64_t paddr;
     void *addr = PNMB(na, slot, &paddr);
     /\* ... work per buffer ... \*/
     nm_i = nm_next(nm_i, lim);
     nic_i = nm_next(nic_i, lim);
   }

>> * The driver is refilling receive buffers so the NIC can keep receiving packets.

>> * It processes buffers in batches: up to IFLIB_MAX_RX_REFRESH each time.

>> * i counts how many buffers we've handled in this batch. n is the total remaining buffers to refill; it decrements every iteration.

>> * For each buffer, the code grabs its slot, figures out the physical address, readies it for DMA, then advances the ring indices (nm_i, nic_i).

>> * The loop stops when either the batch is full (i hits the max) or there's nothing left to do (n == 0). The batch is then "published" to the NIC by the code right after the loop.

>> In essence, a for loop is the go-to choice when you have a clear limit on how many times something should run. It packages initialisation, condition checking, and iteration updates into a single, compact header, making the flow easy to follow.

Total garbage. This has literally zero educational value. I assume Brandi is just trying to make a quick buck, he truly has not even glanced at the output. He should be ashamed of himself.