I recently found that this could be a kind of unofficial motto for our software product. But it might as well be the same for many other software products.
Here's the story:
you're a software tester, writing a test case, either a good old word table, or a java script or a Test Director script.
How many times did you think:
1. This test case is so dumb that even a computer could write it!
2. This test case is so smart that only a computer could write it!
These are 2 of the true powers of the computers:
1. being so dumb and dull to calculate endless combinations of values without pausing at it (how many coffee breaks do you really need as a software tester every day?)
2. at the same time being so smart to find meaningful combinations for special cases where you would have abandonned finding that- case-that-anyway-may-never-occur or most certainly where you would have not assumed its mere existence.
Yes, I know, in the end, computers are not-so-smart items. They are only smart because we feed them the right algorithms (thank god, we may still have a job forever!). But being able to exploit that dumbness to write down necessary but really uninteresting test cases or to let algorithms backtrack to death until they find the solution is really a bliss.
The only curse is that you have to feed them right:
-what are the rules they are supposed to work on (the model in model-based testing)
-how you want them to be smart, because this has a meaning only for you
So their true power is only realized if it's not too much work to set-up the data and if you can find algorithms that won't need too much customization to solve your specific problem. I think that most of the time, this is achievable. The trouble is that you may need to be really smart to do that!