How is a typable seed generated for procedural generation?

I'm wrapping my head around procedural generation, and the difference between it and random generation. I get that the difference is that it's deterministic, which is based off a specific seed value, like all random engines are.

So in C++11, I understand that to get the 'best' random sequences, an std::seed_seq should be used, and it doesn't need to be cryptographically secure, so an std::mt19937 is fine.

In this scenario, I want a bunch of positions for objects in the world so I can generate a level, and then I want to text my friend the seed of this brand new level because it was really cool. But as it is, typing 189151022 140947902 1454660100 853918093 3243866855 is really annoying. So what can I do as a dev to make sure the randomness is preserved with a bit more type-ability?

I thought hash the values as a string and then reverse it, (but then I remembered the point of hashes) or just use the hash itself, but would that be worse as a seed? Or does it even matter, and can I just use "lol" as my seed and have that be just as good as a megabyte-long perfectly random number?

Here's the quick example I made to help me understand it a bit better.

#include <iostream>
#include <random>
#include <array>

using std::cout;
using std::endl;
using std::array;

struct pos
{
    float x, y;
    pos(float x, float y) : x(x), y(y) {}

    void print()
    {
        cout << "(" << x << " " << y << ")" << endl;
    }
};

int main()
{
    //Get seed
    std::random_device rd;
    array<unsigned long, 5> seed = { rd(), rd(), rd(), rd(), rd() };

    //Seed generator
    std::mt19937 generator;
    generator.seed(std::seed_seq(seed.begin(), seed.end()));

    //Setup distribution
    std::uniform_real_distribution<float> distribution(0, 100);

    //Generate the world (or whatever)
    pos a = pos(distribution(generator), distribution(generator));
    pos b = pos(distribution(generator), distribution(generator));
    pos c = pos(distribution(generator), distribution(generator));
    //And many, many more calls to get values from the generator

    a.print();
    b.print();
    c.print();

    //For when I want the same world back
    cout << "Seed: ";
    for (unsigned long s : seed)
    {
        cout << s << " ";
    }
    cout << endl;
}

To be clear, the question I'm asking is:

What should I use for a seed in a procedural generator in a game context, and what are the upsides and downsides of doing it in that fashion?