AGL, 23 bytes

• a programming language i made! check out the link to my github repo.

["aeiouy".vA:-:]5*{r?}%

Explanation:

["aeiouy".vA:-:]5*{r?}%
["aeiouy".vA:-:]        => strs of consonants & vowels
                5*      => 5 of those pairs
                  {r?}% => randomly choose from each str
                           (list of 1-char strs will be all joined as 1 str)

JavaScript, 74

for(a=b=[];a++-5;)b+="bcdfghjklmnpqrstvwxz"[c=new Date*a%20]+"aeiouy"[c%6]

Does not generate all combinations, but I think that all consonants and vowel appear.

JavaScript, 79

for(a=b=[];a--+5;)b+="bcdfghjklmnpqrstvwxz"[c=Math.random()*20^0]+"aeiouy"[c%6]

More "random" version.

Ruby, 61 bytes

Port of l4m2's clever JavaScript solution; give them an upvote!

1until rand(9e99).to_s(36)=~/([^aeiouy\d][aeiouy]){5}/
puts$&

Attempt This Online!

JavaScript (V8), 83 bytes

for(;a=Math.random().toString(36).match(/([^aeiouy\d.][aeiouy]){5}/g),!a;);print(a)

Try it online!

/g makes the result without an extra appearance of pair

-5B emanresu A

Vyxal s, 8 bytes

k¹k∪"5ƈ∩

Try it Online!

    "    # Pair
k¹       # Consonants
  k∪     # And vowels
     5ƈ  # Choose 5 random items from each
       ∩ # Interleave

Thunno 2 J, 9 bytes

5ıkykz,€ɼ

Try it online!

Explanation

5ıkykz,€ɼ  # Implicit input
5ı         # Repeat 5 times:
  ky  , ɼ  #  Random vowel
    kz €ɼ  #  Random consonant
           # Join into a string
           # Implicit output

Zsh --braceccl, 57 bytes

Try it Online!

shuf -n5 <(echo {bcdfghj-np-tvwxz}{aeiouy}|rs 0 1)|rs -g0

Alternates: 67b using jot ; 77b using arrays

Japt -P, 14 bytes

;Cü_èyi%îö5ÃÕ

Test it

;Cü_èyi%îö5ÃÕ
;C                 :Lowercase alphabet
  ü                :Group by
   _               :Passing each character through the following function
    è              :  Count
     yi%           :    "y" prepended with "%", giving the Japt RegEx "%y"=/[aeiouy]/i
        Ã          :End grouping
         ®         :Map
          ö5       :  5 random characters
            Ã      :End map
             Õ     :Transpose
                   :Implicitly join & output

Japt -P, 20 17 bytes

;`Á<`
5Æö iCkU ö

Test it

Note that there is an unprintable character in front of the Á

;          # C = "abcdefghijklmnopqrstuvwxyz"
 `ŒÁ<`     # U = "oueayi"

5Æ         # Do this 5 times:
  ö        #  Pick a random letter from U
    i      #  Prepend: 
     CkU   #   Remove the letters in U from C
         ö #   Get a random letter from the result

-P         # Print all the pairs with no separator

K (ngn/k), 57 47 46 54 bytes

{`prng@0;,/{(1?"bcdfghjklmnpqrstvwxz"),1?"aeiouy"}'!5}

Try it online!

Down 1 byte thanks to ngn

Takes inspiration from the PHP answer. This one now outputs random words at each call, with the cost of 8 extra bytes.

Explanation:

{`prng@0;,/{(1?"bcdfghjklmnpqrstvwxz"),1?"aeiouy"}'!5} Main function. Takes no input
                                                   !5  Generate a array with range from 0 to 4 ([0..4])
                                                  '    For each number...
           {                                     }     Execute a function that...
            (1?"bcdfghjklmnpqrstvwxz"),1?"aeiouy"      Chooses one random consonant, followed by one random vowel
         ,/                                            Joined each of these strings together
 `prng@0;                                              Use current time to set state of randomness (Thus allow random words)

"Random Word Generator", 70 +2 = 72 bytes

C=b c d f g h j k l m n p q r s t v w x z
V=a e i o u y
syllable:$C$V

Set minimum and maximum number of syllables settings to 5 (which I'm counting as flags, so 1 byte each).

This is written in a (WIP) tool I wrote for generating words from a sound inventory for conlanging (making constructed languages). I made the tool due to the other word generators (that I know of) having flaws (in my opinionated opinion).

The above code sets two categories C and V, and defines a syllable as a C followed by a V. The flags (minimum and maximum syllables) define how many syllables will be generated for a given word.

No changed settings, 86 bytes

C=b c d f g h j k l m n p q r s t v w x z
V=a e i o u y
syllable:$C$V$C$V$C$V$C$V$C$V

Due to a bug in my implementation, this solution is extremely slow due to the large syllable size.

C (gcc), 63 bytes

c;f(n){for(n=10;n;81192%c-n&1||putchar(c,n--))c=97+clock()%26;}

Try it online!

05AB1E, 10 bytes

5FžPΩ?žOΩ?

Try it online or output \$n\$ amount of random words.

Explanation:

Pretty straight-forward:

5F      # Loop 5 times:
  žP    #  Push string "bcdfghjklmnpqrstvwxz"
    Ω   #  Pop and push a random character from this string
     ?  #  Output it without newline
  žOΩ?  #  Do the same with string "aeiouy"

Brachylog, 9 bytes

Ḍ;Ẉṣᵐzh₅c

Try it online!

Gives output as a list of letters through the output variable.

   ṣ         Randomly shuffle
 ;  ᵐ        both
Ḍ            the consonants without y
  Ẉ          and the vowels with y,
     z       zip them into pairs,
      h₅     take the first five pairs,
             and output
        c    their concatenation.

Jelly, 13 bytes

Øy,ØYẊ€Zs5ḢŒl

Explanation:

Øy,ØYẊ€Zs5ḢŒl
Øy,ØY         Makes a list of two lists of characters: [[list-of-vowels-with-y], [list-of-consonants-without-y]]
     Ẋ€       Shuffle €ach.
       Z      Zip those two lists together. [[random-vowel, random-consonant],...]
        s5    Split them into chunks of five (because each pair contains two letters, this splits them into chunks of 10 letters)
          Ḣ   Take the list of 5 pairs.
           Œl Make each of the characters in it lowercase
              Implicit concatenation and print.

Try it online!

R, 83 bytes

cat(outer((l<-letters)[a<-c(1,5,9,15,21,25)],l[-a],paste0)[sample(1:120,5)],sep="")

Generate all possible vowel-consonant sequences in a matrix, then randomly sample 5 of them, yielding a 10-letter word.

COBOL, 255

So I'm learning COBOL at the moment. Used this question as some practice. Tried to golf it.

It's 255 without the leading whitespace, and 286 bytes with.

For what it's worth, this runs in Microfocus COBOL for VS2012, and I have no idea if it will run anywhere else.

       1 l pic 99 1 s pic x(26) value'aeiouybcdfghjklmnpqrstvwxz' 1 r
       pic 99 1 v pic 9 1 q pic 99. accept q perform test after varying
       l from 1 by 1 until l>9 compute v=function mod(l,2) compute r=1+
       function random(q*l)*5+v*15+v*5 display s(r:1)end-perform exit

APL 30 26

,('EIOUY'∪⎕A)[6(|,+)⍪5?20]

Explanation is very similar to the past version below, just reordered a bit to golf the solution.

Note: ⎕IO is set to 0

('EIOUY'∪⎕A)[,6(|,(⍪+))5?20]

Explanation:

'EIOUY'∪⎕A    puts vowels in front of all letters.
5?20            for the indexes we start choosing 5 random numbers between 0 and 19
6(|,(⍪+))        then we sum 6 and the random numbers, convert to 5x1 matrix (⍪), add a column before this one containing 6 modulo the random numbers. 
                [[[ this one can be rewritten as: (6|n) , ⍪(6+n)  for easier understanding]]]
,6(|,(⍪+))5?20  the leading comma just converts the matrix to a vector, mixing the vowel and consonants indexes.

Tryapl.org

Pyth, 26 characters

J-G"aeiouy"VT=k+kOJ=J-GJ;k

You can try it in the online compiler here.

Someone posted a very similar challenge but it was closed after I had made a solution. I didn't realize it, but this question actually predates the creation of Pyth. Anyway, here is the breakdown:

J                             Set string J equal to:
  G                            the entire alphabet (lowercase, in order)
 - "aeiouy"                    minus the vowels
           VT                 For n in range(1, 10):
             =k                   Set string k to:
                k                  k (defaults to empty string)
               + OJ                plus a random character from J
                   =J             Set J to:
                      G            the entire alphabet
                     - J           minus J
                        ;     End of loop
                         k    print k

Every time the loop is run, J switches from being a list of consonants to a list of vowels. That way we can just pick a random letter from J each time.
There may be a way to initialize J in the loop or remove the explicit assignments from the loop, but I have not had success with either yet.

K, 40 bytes

,/+5?/:("bcdfghjklmnpqrstvwxz";"aeiouy")

5?"abc" will generate 5 random letters from the given string.

5?/: will generate 5 random letters from each of the strings on the right, producing two lists.

+ transposes those two lists, giving us a list of tuples with one random character from the first list and then one from the second list.

,/ is "raze"- fuse together all those tuples in sequence.

K5 can do this in 33 bytes by building the alphabet more cleverly and then using "except" (^) to remove the vowels, but K5 is much too new to be legal in this question:

,/+5?/:((`c$97+!26)^v;v:"aeiouy")

Unix tools: 73 bytes

And not guaranteed running time :)

</dev/urandom grep -ao '[aeiouy][bcdfghjklmnpqrstvwxz]'|head -5|paste -sd ''

Only problem is that the generated string will start with a "vowel" every time.

(edit: changed ' ' to '' in the args of paste) (another edit: removed -P from grep options, thanks to manatwork)

Javascript, 104 87

a="";for(e=10;e--;)a+=(b=e&1?"bcdfghjklmnpqrstvwxz":"aeiouy")[0|Math.random()*b.length]

golfed a whole lot of simple unnecessary stuff, still not nearly as nice as copys' one

Oh, and that one just opped up during golfing: "dydudelidu"

_{Now I tried one using the 2 characters at once approach. Turns out it's almost the same as copys' second one, so I can't count it, also at 79. a="";for(e=5;e--;)a+="bcdfghjklmnpqrstvwxz"[m=0|20*Math.random()]+"aeiouy"[m%6]}

Processing, 100 99 93 87

int i=10;while(i-->0)"aeiouybcdfghjklmnpqrstvwxz".charAt((int)random(i%2*6,6+i%2*i*2));

Upon closer inspection of the question, I see it doesn't require any output. I've adjusted this accordingly.

PHP, 100 Characters

<?while($i<6){echo substr('bcdfghjklmnpqrstvwxz',rand(0,20),1).substr('aeiouy',rand(0,5),1);$i++;}?>

C: 101

main(){int x=5;while(x-->0){putchar("bcdfghjklmnpqrstvwxyz"[rand()%21]);putchar("aeiou"[rand()%5]);}}

Javascript, 85

for(r=Math.random,s="",i=5;i--;)s+="bcdfghjklmnpqrstvwxz"[20*r()|0]+"aeiouy"[6*r()|0]

If run from the console, output is shown. Explicit display would add alert(s) at 8 chars, still shorter than the other JS solutions.

Thanks C5H8NNaO4 and Howard!

APL (34)

,⍉↑(V[5?6])((⎕A~V←'AEIOUY')[5?20])

J (51)

,|:>(<"1[5?6 20){&.>'aeiouy';'bcdfghjklmnpqrstvwxz'

Java AKA the most verbose language ever created, 176 with help of Doorknob, Daniero and Peter Taylor (thanks guys!)

class w{public static void main(String[]a){int i=11;while(--i>0)System.out.print((i%2==0?"aeiouy":"bcdfghjklmnpqrstvwxz").charAt(new java.util.Random().nextInt(6+(i%2)*14)));}}

Ungolfed:

    class w {

        public static void main(String[] a) {
            int i = 11;
            while (--i > 0) {
                System.out.print((i % 2 == 0 ? "aeiouy" : "bcdfghjklmnpqrstvwxz").charAt(new java.util.Random().nextInt(6 + (i % 2) * 14)));
            }
     }

}

R: 105 characters

a=c(1,5,9,15,21,25)
l=letters
s=sample
cat(apply(cbind(s(l[-a],5),s(l[a],5)),1,paste,collapse=""),sep="")

Ruby: 70 66 characters

10.times{|i|$><<["aeiouy"*4,"bcdfghjklmnpqrstvwxz"][i%2][rand 20]}

Sample run:

bash-4.1$ ruby -e '10.times{|i|$><<["aeiouy"*4,"bcdfghjklmnpqrstvwxz"][i%2][rand 20]}'
izogoreroz

bash-4.1$ ruby -e '10.times{|i|$><<["aeiouy"*4,"bcdfghjklmnpqrstvwxz"][i%2][rand 20]}'
onewijolen

bash-4.1$ ruby -e '10.times{|i|$><<["aeiouy"*4,"bcdfghjklmnpqrstvwxz"][i%2][rand 20]}'
amilyfilil

F#, 166 characters

open System;String.Join("",(Random(),"aeiouybcdfghjklmnpqrstvwxz")|>(fun(r,s)->[0..5]|>List.collect(fun t->[s.Substring(6+r.Next()%20,1);s.Substring(r.Next()%6,1)])))

Objective-C, 129

main(){int i=10;while(i-->0)printf("%c",[(i%2==0)?@"aeiouy":@"bcdfghjklmnpqrstvwxz"characterAtIndex:arc4random()%(6+(i%2)*14)]);}

With the help of Daniero

(I love to use the tends to operator (-->)

Ruby: 56 characters

([v=%w(a e i o u y),[*?a..?z]-v]*5).map{|a|$><<a.sample}

Example outputs:

• itopytojog
• umapujojim
• ipagodusas
• yfoqinifyw
• ebylipodiz

PHP 79 bytes

<?for($c=bcdfghjklmnpqrstvwxz,$v=aeiouy;5>$i++;)echo$c[rand()%20],$v[rand()%6];

Fairly concise.

GolfScript, 32 characters

['aeiouy'.123,97>^]5*{.,rand=}%+

Run it online.

Python, 81

from random import*
print''.join(map(choice,["bcdfghjklmnpqrstvwxz","aeiouy"]*5))

Good luck pronouncing them.