Regex (ECMAScript), 19 bytes

/\bill(?![aiouy])/i

Try it online!

Explanation

We look for ...

/             //
  \b          // a word boundary
  ill         // followed by "ill"
  (?![aiouy]) // not immediately followed by a, i, o, u or y
/i            // in case-insensitive mode

Rust, 117 91 bytes

Requires inputs to be lowercased and it might break horrendously on multibyte characters as per the challenge's allowances. Officially only supports single-byte character input.

|s:&str|s.split(' ').any(|w|w.starts_with("ill")&&(w.len()<4||!"aiouy".contains(&w[3..4])))

Ungolfed and explained:

// Non-regex answer; unless depending on flavor-specific behavior, 
// there's two regex answers already, they're just tagged as JS (ES6)
fn sick(album: &str) -> bool {
  // Rely on implicit returns
  album
    .split(' ') // split on literal space and iterate over the words
    .any(|word| // Check if any of the splits match a predicate
      word.starts_with("ill") // explains itself
      && (
        word.len()<4 // "ill" is the whole word, sick
        // OR the title does not match the pattern of false positives
        || !"aiouy".contains(&w[3..4]) // so it's sick
        // Rust doesn't allow byte indexing of strings, as some indices
        // may not be whole characters, it does allow indexing ranges
        // So this is effectively &w[3], but it panics if the char at
        // this position happens to be more than one byte long
      )
    )
}

Rust Playground link

Japt -¡, 13 bytes

Takes input in lowercase

pÊè`%ßé[^Ãäu]

Try it

pÊè`...     :Implicit input of string
p           :Append
 Ê          :  Its length
  è         :Count the occurrences of
   `...     :  Compressed string "%bill[^ayiou]"=/\bill[^ayiou]/g
            :Implicit output of result as a boolean (0 is falsey)

JavaScript (Node.js), 29 bytes

s=>/\bill[^ayiou]/i.test(s+1)

Try it online!

Obvious

R, 35 bytes

\(x)grepl("\\bIll([^aiouy]|$)",x,T)

Attempt This Online!

grepl(
  "            
  \\b          # a word boundary
  Ill          # followed by "Ill"
  ([^aiouy]|$)  # followed by either a non-aiouy character OR end of string"
  "  
  x,           
  T            # ignore.case = TRUE
)

Obviously we could port the same pattern used in JS answers:

R, 36 bytes

\(x)grepl("\\bIll(?![aiouy])",x,T,T)

Attempt This Online!

Lua, 117 bytes

k="ill[bcdefghjklmnopqrstvwxz ]"S=io.read()print(S:find("^"..k)or S:find(" "..k)or S:find("^ill$")or S:find(" ill$"))

Takes lowercase input. Outputs a positive integer or two (truthy) if sick, and the string nil if a false positive is found.

Turns out Lua having nothing resembling regex makes it kind of…bad. I hate this solution and I hope someone finds a way to golf it somehow.

I was going to give Compressed Lua a test run here, but it's still in development :( maybe next time buddy

Try it online!

Perl 5, 19 bytes

$_=/\bill[^aiouy]/i

Try it online!

This is like @Arnauld's Regex (ECMAScript) answer except:

• Perl keeps newlines inside inputs, so my RegEx can match on it using just a character class and no negative lookahead
• -p enables a sed-like input reading and printing loop
• Perl has 1 as true and "" as false, so inputs must be passed one-at-a-time
• Test it like echo Illmatic | perl -pe '$_=/\bill[^aiouy]/i'

05AB1E, 19 bytes

ð.ø'´™ðìAžOÀ¦мðª«åà

Input in full lowercase.

Try it online or verify all test cases.

Explanation:

ð.ø       # Surround the (implicit) input-string with leading/trailing space " "
'´™      '# Push dictionary string "ill"
   ðì     # Prepend a space: " ill"
A         # Push the lowercase alphabet
 žO       # Push the vowels: "aeiouy"
   À¦     # Rotate once and remove the first character, to remove the "e": "iouya"
     м    # Remove all those characters from the alphabet
      ðª  # Convert it to a list of characters, and append a space " "
«         # Merge all those characters to the earlier " ill":
          #  [" illb"," illc"," illd"," ille",...," illx"," illz"," ill "]
 å        # Check for each if it's a substring of the modified input-string
  à       # Check if any is truthy (by taking the maximum)
          # (which is output implicitly as result)

See this 05AB1E tip of mine (section How to use the dictionary?) to understand why '´™ is "ill".

PS: '´™ðì could alternatively be '´™1ú; '´™4j; „ ´™¦; or „´™ Á for the same byte-count.

Charcoal, 21 bytes

⊙Φ⪪⁺ ↧Ｓ illκ⬤aiouy⌕ιλ

Try it online! Link is to verbose version of code. Outputs a Charcoal boolean, i.e. - for an ill vinyl, nothing if not. Explanation:

      Ｓ                 Input string
     ↧                  Lowercased
   ⁺                    Prepend a space
  ⪪     ill             Split on literal string ` ill`
 Φ         κ            Remove first element
⊙                       Any suffix satisfies
             aiouy      Literal string `aiouy`
            ⬤           All letters satisfy
                   ι    Current element
                  ⌕     Does not begin with
                    λ   Current letter
                        Implicitly print

Dyalog APL, 36 bytes

I'm sure using the built-in regex library is shorter, but this was more fun

{∨/≠⌿↑((⊂'ill'),¨''⊂⍛,'aiouy')∘.⍷⊂⍵}­⁡​‎‎⁡⁠⁢⁤‏⁠‎⁡⁠⁣⁡‏⁠‎⁡⁠⁣⁢‏⁠‎⁡⁠⁣⁣‏⁠‎⁡⁠⁣⁤‏⁠‎⁡⁠⁤⁡‏⁠‎⁡⁠⁤⁢‏⁠‎⁡⁠⁤⁣‏⁠‎⁡⁠⁤⁤‏⁠‎⁡⁠⁢⁡⁡‏‏​⁡⁠⁡‌⁢​‎‎⁡⁠⁢⁡⁢‏⁠‎⁡⁠⁢⁡⁣‏⁠‎⁡⁠⁢⁡⁤‏⁠‎⁡⁠⁢⁢⁡‏⁠‎⁡⁠⁢⁢⁢‏‏​⁡⁠⁡‌⁣​‎‎⁡⁠⁢⁢⁣‏⁠‎⁡⁠⁢⁢⁤‏⁠‎⁡⁠⁢⁣⁡‏⁠‎⁡⁠⁢⁣⁢‏⁠‎⁡⁠⁢⁣⁣‏⁠‎⁡⁠⁢⁣⁤‏⁠‎⁡⁠⁢⁤⁡‏‏​⁡⁠⁡‌⁤​‎‎⁡⁠⁢⁣‏⁠‎⁡⁠⁢⁤⁢‏⁠‎⁡⁠⁢⁤⁣‏⁠‎⁡⁠⁢⁤⁤‏⁠‎⁡⁠⁣⁡⁡‏⁠‎⁡⁠⁣⁡⁢‏⁠‎⁡⁠⁣⁡⁣‏‏​⁡⁠⁡‌⁢⁡​‎‎⁡⁠⁢⁢‏‏​⁡⁠⁡‌⁢⁢​‎‎⁡⁠⁤‏⁠‎⁡⁠⁢⁡‏‏​⁡⁠⁡‌⁢⁣​‎‎⁡⁠⁢‏⁠‎⁡⁠⁣‏‏​⁡⁠⁡‌­
       (⊂'ill'),¨                     # ‎⁡'ill' combined with each of
                 ''⊂⍛,                # ‎⁢An empty string
                      'aiouy'         # ‎⁣and each vowel
      (                      )∘.⍷⊂⍵   # ‎⁤Outer product find with the input
                                      # ‎⁤This gives occurrences of 'ill' followed by the occurrences of every other vowel combination (except 'e') 
     ↑                                # ‎⁢⁡Mix into a matrix
   ≠⌿                                 # ‎⁢⁢XOR down the columns
 ∨/                                   # ‎⁢⁣or-over (i.e. "any")
💎

Created with the help of Luminespire.

GNU sed 17 16 18 bytes

Thanks to @someone in the comments for pointing out I had this solution backwards, that allowed me to shave off the no-matches check and that I needed a negative match. At first I thought I could skip the negative, but that flags for ill on any input not containing ill

/\bill[^aiouy]/!q1

Explained:

/                  # Start pattern
 \b                # Match word boundaries
   ill             # Match literal "ill" as start of a word
      [^aiouy]     # Match any not[aiouy] directly after
             /     # End pattern
              !    # If not found, execute command
               q1  # exit with status 1. Evaluates to false as per POSIX

q (or Q to silence output) is a GNU extension to the program to set the exit status if a condition is matched. See the GNU sed script overview for examples, and the command list for the command's description.