Higher level NN algorithm strategy?

Hi,

I took Dr. Hinton's NNfML class a few months ago. One of the concepts that stuck with me was the idea that at present, the impression I was given is that people are making large neural networks to solve a single complex problem. The second impression I was given is that there is no 'good' way to do neural networks, there are only 'better' ways to set up neural networks. It's more of an art than a science (albeit with a healthy dose of either).

So if someone writing a neural network needs to go on intuition and heuristics, what if the problem of writing neural networks is itself a problem suited to be solved by a neural network?

This brings me to my proposal. In order to use NN to generate NN, you would need building blocks. If there were a common interface standard for images, sound sequences, etc. such that smaller NNs could be written and stored in a common database, it would be possible to algorithmically generate a number of 'utility' neural networks. From this, you could use these to generate larger NNs. This provides a few benefits -

1. You know what each part of the neural network does, so it might provide an ability to 'track' the information flow
2. You don't need to re-train the utility NNs, just the interface layers between each of the utility NNs and the output.
3. If this repository of utility NNs implements the standard, the community could submit various implementations of a particular utility NN and the user would select the one with the highest success ratio. This ensures that on average, the quality of the repository increases over time.
4. This strategy does not preclude enormous utility NNs as is the current standard - you would just make use of one of these in place of several smaller utility networks.
5. Since each utility NN in the repository would be small, it might be possible to generate them algorithmically - for example, by scraping the web or media.
6. Finally, with a consistent enough set of building blocks, it might be possible to train a NN in the procedures by which a NN is written, and feed it back into itself. A NN algorithm using utility NNs to generate new utility NNs, etc.

Has this idea been done? Would there be any interest in a potential media for this kind of interaction?

Also forgive me if I have not made something particularly clear. It's hard to articulate neural-networkception.