Five-letter word patterns: how to narrow guesses without guessing randomly

Quick strategy

Write down the constraint before you pick the next word: fixed letters, required letters, rejected letters, and the shape of the word. Then use the linked GridHint route to filter or browse. This is evergreen solving advice only; it does not reveal current-puzzle solutions or date-tied hints.

What "pattern" actually means here

A pattern is everything you already know about the answer:

• Fixed positions - letters confirmed in a specific slot (e.g. the third letter is A).
• Floating letters - letters that belong in the word, but not in the slot you tried them.
• Excluded letters - letters you've already ruled out entirely.
• Structural shape - the consonant/vowel rhythm, doubled letters, common endings (-OUND, -IGHT, -ATCH).

The trap is treating these as four separate facts. The skill is combining them. A word with _R_ _ E plus a floating O and an excluded T is a much smaller universe than any of those constraints on its own.

Reading the pattern before you type

Before your next guess, run through this in order:

1. List your fixed slots. Write them down if you have to. _ R _ _ E is different from _ _ R _ E, and people misread their own grid more often than they admit.
2. List your floating letters. Note which positions you've already tried them in - those slots are now off-limits for that letter.
3. List your excluded letters. Cross them off mentally so you stop reaching for them.
4. Look at the shape. Where are the vowels? Where is the most common position for the remaining consonants?

Only then start generating candidates.

High-value patterns to recognize

A few patterns appear often enough that recognizing them shortcuts the work:

The point isn't to memorize a table. It's to notice when your pattern *matches* one of these shapes, so you can mine the right neighborhood instead of brute-forcing the whole dictionary.

Constraint stacking: the move that saves guesses

Each constraint cuts the candidate space, but the cuts compound. One green letter might leave hundreds of possibilities. Add a yellow letter and four grays, and you're often down to dozens. Add a second green and you're frequently in single digits.

A practical example. You know:

• Position 2 is R (green)
• The word contains E somewhere, but not in position 5 (yellow)
• S, T, A, N are excluded (gray)

Without stacking: there are far too many _R___ words to enumerate. With stacking: you've ruled out the most common consonant (S), the most common ending letters (T, N), and the most common vowel after E (A). You're now looking for an _R___ word containing E (not at the end) with a non-S/T/A/N letter set - words like BRIDE, BREWS (no, S excluded), PRIDE, PRIED, CREWS (no), CRIME, DROVE, PROBE. The list is small enough to eyeball.

The discipline is to *write the constraints down* before generating candidates, not after. Generating first and then filtering is how good letters get wasted.

When to use a list vs. a solver

Two different tools, two different jobs.

• Use a word list when you want to browse - you have a vague shape in mind, you want to see what words exist with a certain ending, or you're learning the territory. /5-letter-words/ is the right entry point for this.
• Use a pattern solver when you have specific constraints - fixed positions, included letters, excluded letters - and you want the filtered set, not the full set. /word-pattern-solver/ takes those constraints and returns the words that fit.

The mistake people make is reaching for the list when they should be reaching for the solver. If you already know three letters and two exclusions, you don't want to scan thousands of words. You want the filtered handful.

Choosing your next guess from the candidate list

Once you've narrowed the field, the next guess isn't always the most "likely" answer. Sometimes it's the word that best *distinguishes* between your remaining candidates.

Suppose you're down to BRIDE, PRIDE, CRIME, DROVE, PROBE. Guessing any of them might be right - but if you guess BRIDE and it's wrong, you haven't done much to separate the remaining four. A guess like COMPO or BUMPY (assuming guesses still have value) probes B, C, P, M, and O simultaneously, telling you which candidate cluster you're in.

This trick - burning a guess to gather information rather than to win - only makes sense when you have guesses to spare. Late in a puzzle, just take the most likely word.

Common mistakes to avoid

• Reusing an excluded letter. Easy to do under time pressure. Slow down for two seconds and check.
• Putting a floating letter back in the slot you already tried. A yellow E in position 3 means position 3 is *not* where E lives.
• Ignoring shape. If your pattern is _ _ O _ _ and you keep guessing words ending in -E, you're not using your information.
• Going to the list when you should be filtering. Browsing is fun. Solving is faster.
• Forgetting doubled letters exist. Many guessers assume each slot is a distinct letter and miss LLAMA, MUMMY, or OOZED-style answers.

A short worked example

Say your grid looks like this after two guesses:

• Slot 1: unknown
• Slot 2: O (green)
• Slot 3: unknown
• Slot 4: S (yellow, was tried in slot 4 and is wrong there)
• Slot 5: unknown
• Excluded: A, E, T, R

Walk it: vowel is locked to O in slot 2. A and E are out, so the second vowel - if there is one - must be I, O, U, or Y. S is in the word but not in slot 4. T and R are gone, knocking out a huge number of common endings.

Candidates that fit: HOIST (no - T excluded), MOIST (same), JOIST (same), FOIST (same)... so -OIST is dead. Try -OSSY: BOSSY, MOSSY. Try -OUSY: LOUSY, MOUSY. Try slot-1-S: SPOON (no second S), SCOOP (same).

You're now choosing between maybe four or five real candidates instead of guessing blind. Hand the constraints to /word-pattern-solver/ and you'll get the exact filtered set.

Related tools and references

• /5-letter-words/
• /word-pattern-solver/