An incompressible string is one that cannot be compressed with a particular compression algorithm because it lacks sufficient redundancy. No strings, except the empty string, are incompressible under all possible compression algorithms, since a compression algorithm can be constructed that takes the supposedly incompressible string and converts that to the empty string as its compressed version and uses a zero byte followed by the output of a common compression algorithm for all other strings. That algorithm successfully compresses the string.
Example
Suppose we have the string 12349999123499991234, and we are using a compression method that works by putting a special character into the string (say '@') followed by a value that points to an entry in a lookup table (or dictionary) of repeating values. Let's imagine we have an algorithm that examines the string in 4 character chunks. Looking at our string, our algorithm might pick out the values 1234 and 9999 to place into its dictionary. Let's say 1234 is entry 0 and 9999 is entry 1. Now the string can become:
@0@1@0@1@0
Obviously, this is much shorter, although storing the dictionary itself will cost some space. However, the more repeats there are in the string, the better the compression will be.
Our algorithm can do better though, if it can view the string in chunks larger than 4 characters. Then it can put 12349999 and 1234 into the dictionary, giving us:
@0@0@1
Even shorter. Now let's consider another string:
1234999988884321
This string is incompressible by our algorithm. The only repeats that occur are 88 and 99. If we were to store 88 and 99 in our dictionary, we would produce:
1234@1@1@0@04321
Unfortunately this is just as long as the original string, because our placeholders for items in the dictionary are 2 characters long, and the items they replace are the same length. Hence, this string is incompressible by our algorithm.