You know the dance. You type ps auxf | grep something, hit enter, squint, press up-arrow, add | awk '{print $2}', hit enter, squint, up-arrow, append | sort -u, repeat. Every iteration re-runs the whole pipeline, even the expensive parts. If the first command takes 30 seconds (or charges you cloud API credits), your pipeline-building feedback loop is dead before it starts.

up — the Ultimate Plumber by Mateusz Czapliński — fixes this in the most Unix way imaginable: it reads stdin once, then gives you a TUI where the pipeline you're typing is re-executed against that buffered input on every keystroke. You see the result of your evolving filter immediately, with no re-fetching, no re-running, no rate-limit anxiety.

Install from github.com/akavel/up (single Go binary, no dependencies). Then:

$ lsof | up

The top pane shows the buffered output of lsof. The bottom is an input line. Type:

grep TCP

The top pane immediately re-renders, filtered. Keep typing:

grep TCP | awk '{print $1, $9}' | sort | uniq -c | sort -rn | head

Every character updates the output. There is no execute step. When you're happy, hit Ctrl-X and up writes your pipeline to ./up1.sh as a real shell script you can commit.

The killer case is expensive or non-idempotent input:

# Hit one slow API, then iterate freely against the cached body
$ curl -s https://api.example.com/v1/everything | up

# Or a 4GB log file you don't want to re-stream
$ zcat huge.log.gz | up

# Or stdin from a remote box you SSH'd into
$ ssh prod1 'journalctl -u nginx --since "1 hour ago"' | up

One curl, one zcat, one ssh round-trip — then arbitrary pipeline iteration against the captured bytes. The mainstream alternative (shell history + arrow keys) re-runs the source command every single time you tweak a filter. Watch your AWS bill agree.

A few less-obvious moves:

• F5 forces a re-read from the original stdin source, in case it was a FIFO or you want a fresh snapshot. Otherwise the buffer is frozen.
• Pipelines are bash, not a DSL. You get the full shell — process substitution, $(), here-strings, tee >(...), the works. This is not a toy reimplementation.
• Combine with jq exploration. Pipe a giant JSON blob into up and incrementally type jq '.items[] | select(.status=="failing") | {name, last_seen}' watching each filter step refine the output. This single use case justifies the install.
• Use it as a CSV/log triage harness. cat access.log | up then iterate with awk, grep -v, cut -d' ' until you've narrowed to the rows you wanted. The script you save is reproducible.

Two real gotchas. First, up buffers stdin in memory by default — for genuinely huge inputs, pre-filter before piping in, or use the -b flag to bound the buffer. Second, your pipeline runs on every keystroke, so don't pipe in rm -rf; up is for read-side filters. Stick to grep/awk/sed/jq/sort/cut and friends and you cannot hurt yourself.

The deeper lesson: separating data acquisition from data shaping is one of those ideas that feels obvious once you've used it for a week, and indefensibly absent from shell ergonomics for the previous 50 years.