• The writing process (echo in your case) is not oblidged to write anything to its stdout (for instance, echo -n would not write anything to its stdout and exit successfully).
• It's also able to make arbitrary delays writing its data (either because it wants to make such delays or because it has been preempted by the OS or sleeps in some syscall waiting on some busy system resource etc).
• The OS buffers transfers over pipes. This means what the writing process sends to a pipe, might come out in arbitrary chunks on the reading side.¹
• There are only two ways to know the writing side has no more data to send over the pipe:
  • Somehow encode this in the data itself (this means using an agreed upon data transfer protocol between the writer and the reader).
  • The writer might close its side of the pipe which would result in the "end of file" condition on the reader side (but only after the buffer is drained and one another call to read is attempted, which fails).

that would not meant the spawned process would not have stdin (or "initial stdin" or whaveter), instead, its stdin would be connected to the same stream your shell receives your keyboard import from (so you could directly type something to your process's stdin).

• The writing process (echo in your case) is not oblidged to write anything to its stdout (for instance, echo -n would not write anything to its stdout and exit successfully).
• It's also able to make arbitrary delays writing its data (either because it wants to make such delays or because it has been preempted by the OS or sleeps in some syscall waiting on some busy system resource etc).
• The OS buffers transfers over pipes, and often the code in the program does this, too—though it may not be apparent for an inexperienced programmer. This means what the writing process sends to a pipe, might come out in arbitrary chunks on the reading side.¹
• There are only two ways to know the writing side has no more data to send over the pipe:
  • Somehow encode this in the data itself (this means using an agreed upon data transfer protocol between the writer and the reader).
  • The writer might close its side of the pipe which would result in the "end of file" condition on the reader side (but only after the buffer is drained and one another call to read is attempted, which fails).

that would not meant the spawned process would not have stdin (or "initial stdin" or whaveter), instead, its stdin would be connected to the same stream your shell receives your keyboard input from (so you could directly type something to your process's stdin).

• The writing process (echo in your case) is not oblidged to write anything to its stdout (for instance, echo -n would write zero bytes to its stdout and exit successfully).
• It's also able to make arbitrary delays writing this data (either because it wants to make such delays or because it has been preempted by an OS, sleeps in some syscal waiting on some busy system resource etc).
• The OS buffers transfers over the pipe. This means what the writing process sends to a pipe, might come out in arbitrary chunks on the reading side.
• There are only two ways to know the writing side has no more data to send over the pipe:
  • Somehow encode this in the data itself (this means using an agreed upon data transfer protocol between the writer and the reader).
  • The writer might close its side of the pipe which would result in the "end of file" condition on the reader side (but only after the buffer is drained and one another call to read is attempted, which fails).

Let's wrap this up: the behaviour you're observing is correct and normal. If you expect to get any data from stdin, you must not expect it to be readily available. If you also don't want to block on stdin, then create a goroutine which would do blocking reads from stdin in an endless loop and pass them up over a channel (possibly after certain processing, if needed).

• The writing process (echo in your case) is not oblidged to write anything to its stdout (for instance, echo -n would not write anything to its stdout and exit successfully).
• It's also able to make arbitrary delays writing its data (either because it wants to make such delays or because it has been preempted by the OS or sleeps in some syscall waiting on some busy system resource etc).
• The OS buffers transfers over pipes. This means what the writing process sends to a pipe, might come out in arbitrary chunks on the reading side.¹
• There are only two ways to know the writing side has no more data to send over the pipe:
  • Somehow encode this in the data itself (this means using an agreed upon data transfer protocol between the writer and the reader).
  • The writer might close its side of the pipe which would result in the "end of file" condition on the reader side (but only after the buffer is drained and one another call to read is attempted, which fails).

Let's wrap this up: the behaviour you're observing is correct and normal. If you expect to get any data from stdin, you must not expect it to be readily available. If you also don't want to block on stdin, then create a goroutine which would do blocking reads from stdin in an endless loop (but checking for the EOF condition) and pass collected data up over a channel (possibly after certain processing, if needed).

¹ This is why certain tools which usually occur between two pipes in a pipeline, such as grep, might have special options to make them flush their stdout after writing each line — read about the --line-buffered option in the grep manual page for one example. People who are not aware of this "full buffering by default" semantics are puzzled why tail -f /path/to/some/file.log | grep whatever | sed ... seems to stall and not display anything when it's obvious the monitored file gets updated.

As a side note: if you were to run your binary "as is", like in

$ ./stdin 

that would not meant the spawned process would not have stdin (or "initial stdin" or whaveter), instead, its stdin would be connected to the same stream your shell receives your keyboard import from (so you could directly type something to your process's stdin).

The only sure way to have a process's stdin connected to nowhere is to use

$ ./stdin </dev/null 

on Unix-like OSes and

C:\> stdin <NUL 

on Windows. This "null device" makes the process see EOF on the first read from its stdin.