The "second prompt" you saw was real, and nothing was stuck. Bash does not wait for commands launched through process substitution like >(tee -a g*), so the prompt reappears immediately while tee is still starting up. A moment later, tee reads "text1" and writes it to its stdout — which is still your terminal — so the word appears after the prompt, looking like a second shell prompt waiting for input. Nothing was blocked; Ctrl+C was never necessary.
Why this happens
When you write:
echo 'text1' > >(tee -a g*)
bash creates a temporary named pipe (or /dev/fd path), launches tee -a g* in the background with that pipe connected to its standard input, and connects the left side of the redirect to the same pipe. Two things follow from this design:
- The substitution is asynchronous. The foreground command (
echo) finishes instantly, and bash doesn't track the backgroundteeas part of the command. The prompt returns beforeteehas done anything visible. - Only tee's stdin was redirected. The
> >(...)construct redirects the output ofechointo the substitution — it says nothing about whereteesends its output. By default that's your terminal, so "text1" gets echoed back to you right after the prompt.
The AI explanation you found is half right: the asynchrony is real. What it misses is the second half — the stray text isn't a rendering quirk of the prompt, it's tee writing its normal output to the terminal.
How to verify it yourself
Slow the substitution down and watch the timing. If the shell were genuinely blocked, no prompt would appear until tee finished:
echo 'text1' > >(sleep 2; tee -a g*)
The prompt comes back instantly. Two seconds later, "text1" appears on screen and lands in your files. That delay between prompt and output is the signature of an asynchronous background process, not a hung shell.
A second check: your own ls -a test already proved it. If the shell were waiting on tee, that command would never have executed when you typed it. It ran immediately, which means the prompt was live and accepting input the whole time.
A third check confirms where the output goes:
echo 'text1' > >(tee appended.txt > /dev/null)
Here tee's stdout is explicitly sent to /dev/null, so nothing extra appears on the terminal — but the file is still appended correctly.
The right way to append the same line to multiple files
Process substitution works here, but the ordinary pipe is simpler and behaves predictably:
echo 'text1' | tee -a file1 file2 file3
With a pipe, bash waits for tee to exit before returning the prompt, so there's no race and no stray output — well, almost none: tee still copies its input to stdout by default. If you don't want the line echoed to your terminal, redirect it:
echo 'text1' | tee -a g* > /dev/null
Note where that redirect sits: outside the command, applying to tee's stdout. That placement matters — see the next section.
If you prefer to keep the process-substitution form, make it synchronous by adding a wait:
echo 'text1' > >(tee -a g* > /dev/null); wait
In bash, wait without arguments also waits for process-substitution children, so the prompt won't return until tee is done.
A trap to avoid: redirecting to /dev/null in the wrong place
A tempting "fix" is to move the redirect inside the substitution:
echo 'text1' > >(tee -a g* > /dev/null) > /dev/null
or worse, redirecting the whole command:
echo 'text1' > >(tee -a g*) > /dev/null
Redirections are processed left to right, and the last one targeting a file descriptor wins. In the second example, the > /dev/null overrides the earlier connection to the substitution pipe, so echo writes to /dev/null, tee reads nothing, and your files end up untouched — silently. If you use both forms, keep the /dev/null redirect on tee itself, inside the parentheses, and leave the substitution redirect intact.
Prevention and habits
- Prefer a plain pipe with
teeunless you specifically need process substitution (e.g., when the sink isn't a simple command). - Whenever you use
> >(...), decide deliberately where the inner command's stdout should go. - Remember that process substitution doesn't participate in the normal wait cycle; add
waitif ordering matters. - Test timing-sensitive shell behavior with an injected
sleep— it makes async vs. sync behavior immediately visible.
Frequently Asked Questions
Is the text that appears after the prompt actually a prompt?
No. It's the output of tee arriving after bash printed the real prompt. The real prompt was already active — which is why your ls -a executed immediately when you typed it.
Did I need to press Ctrl+C?
No. Nothing was blocked. tee exits on its own once it finishes reading the pipe, and the shell was never waiting on it in the first place.
Why does tee print the text to the terminal at all?
Because tee's purpose is to copy its input to both the files you name and its stdout. Only its stdin was redirected by the substitution; its stdout defaulted to your terminal. Add > /dev/null after tee (inside the parentheses) to silence it.
Does the pipe form wait for tee to finish?
Yes. In echo 'text1' | tee -a files..., tee is a foreground member of the pipeline, so bash waits for it. That's one reason the pipe form is less surprising.
Why did my files stay empty when I redirected to /dev/null?
Because the redirect was placed after the substitution, it overrode the connection between echo and tee's stdin. The text went to /dev/null and tee never received anything. Put the /dev/null redirect on tee's stdout instead.
Is process substitution bad practice, then?
Not at all — it's a powerful tool for feeding a command's output into something that expects a file path. Just be aware that the substituted process runs asynchronously and manage its stdout explicitly.