CeWL written in Python
You have quite a few methods that need to run for all words. Currently you always make sure that you output a list again, but you could use generator expressions to avoid these intermediate lists.

from typing import Generator, Iterable

REMOVE_PUNCTUATION = str.maketrans('', '', string.punctuation)

def filter_words(words: Iterable[str], max_length: int) -&gt; Generator[str, None, None]:
    """
    Filters each of the words by the criteria passed by the user. Also
    ensures that the word is a "word" (no numbers or special characters).

    :param Iterable[str] words: Words to filter
    :param int max_length: Max word length

    :return Generator[str, None, None]: Filtered words
    """
    return (word for word in words if len(word) &lt;= max_length and word.isalpha())

...    

def get_words(url: str) -&gt; Generator[str, None, None]:
    """
    Returns all the words in the website. Steps this function takes:

    1. Get all text from website
    2. Creates a list with words that have punctuation removed
    3. Removes newlines from each word in the list and lowers it
    4. Removes each "" in the list and joins to a string
    5. Returns a list of each word as an element of the list

    :param str url: Url of website

    :return Generator[str, None, None]: Iterable of all text in website
    """
    body = urllib.request.urlopen(url).read()
    soup = BeautifulSoup(body, 'lxml')
    texts = soup.findAll(text=True)

    # Steps begin #
    visible_texts = filter(visible_tag, texts)
    words = (str(word).translate(REMOVE_PUNCTUATION).rstrip().lower()
             for word in visible_texts)
    return filter(None, words)


Note the () instead of []. I also made the trans a global constant instead of re-creating it every iteration, grouped up some of the methods and used the faster LXML parser. The generator expression will be run by the call set(words) in main.

Your write_to_file can also be slightly improved by using writelines:

def write_to_file(filename: str, words: Iterable[str]) -&gt; None:
    """
    Creates a file in the same directory as the file.

    :param str file_name: Filename of word file
    :param Iterable[str] words: Words to write to file

    :return None:
    """
    with open(f"{FILE_DIRECTORY}/{filename}", "w") as file:
        file.writelines(f"{word}\n" for word in words)


You might want to consider using requests instead of urllib, since it is much more usable (although the difference in this case is negligible). Instead of manually parsing sys.argv, you could use argparse, which allows much more complicated argument parsing and automatic help message generation.

Regarding style, PEP8, the official style-guide, recommends using less than 80 characters per line, which your code does not and mine mostly does (stupid signature for generator type...). However, larger values are also acceptable, if applied consistently. More than 100 characters should be avoided nevertheless.