Checking if all elements are prime I've often come across problems where (as a subproblem) I need to decide whether a list of numbers contains only primes or at least one nonprime.  Is there an efficient way to do this?
Right now I tend to check all to see if they pass a probable-prime test, then use a primality-proving program on each in turn.  (Nothing drastic like ECPP, just BPSW for numbers under $2^{64}$ and APR-CL for larger numbers.  If the numbers are large I need specialized software to do this efficiently.)
Can this be reasonably improved?  I'm actually looking for something efficient in practice (see note), so don't bring up AKS or the like.
Maybe testing for small prime factors is worthwhile -- build up a product of some small primes and take GCDs.
Note
This question could have been asked either here or on StackOverflow; I thought that if I posted it there I would get only tweaks rather than (possibly) a better approach.
 A: In some applications one can perform the primality tests "lazily" (on demand). Even better, in some cases one can completely eliminate the primality tests by simply proceeding as if they were primes, then backing up if one later finds that there are not, e.g. if a zero divisor is encountered (Lenstra calls this a side exit from an algorithm - but the idea is much older). For example, this technique may be used while performing linear algebra computations over the "field" $\rm\:\mathbb Z/n\:.\:$ It is also used in the elliptic curve integer factorization algorithm (e.g. search for "side exit" in H. Cohen: A course in computational algebraic number theory). For another example of such techniques see  D.J. Bernstein Fast ideal arithmetic via lazy localization. 
Also worth stressing is that for many applications it suffices to work with coprimes rather than primes. For example, see section $4.8$ on the concept of a gcd-free basis in Bach and Shallit: Algorithmic Number Theory.
Without knowing any further details of your application, it is impossible to say if any of these techniques apply. Such techniques deserve to be much better known. They are apparently little-known outside the computational number theory community.
