Document where Port sits relative to inf-clojure, monroe, and CIDER

Frames the four tools as a ladder of protocol richness, with each
project's bulk concentrated wherever its protocol has gaps.

Author: bbatsov

README.md

@@ -20,6 +20,63 @@ completion, Port follows monroe's lead and implements such commands by simply
 evaluating a Clojure form (e.g. `(clojure.repl/doc foo)`) and printing the
 result into the REPL buffer.
 
+## How does it compare to other Clojure tools for Emacs?
+
+The Clojure-on-Emacs landscape can be thought of as a ladder where each rung
+adds structure to how the editor talks to a running Clojure. Roughly:
+
+| Tool             | Protocol                              | Server-side deps              |
+|------------------|---------------------------------------|-------------------------------|
+| [inf-clojure][]  | comint over stdio (or a socket REPL)  | none                          |
+| **Port**         | prepl (TCP)                           | none — built into Clojure     |
+| [monroe][]       | nREPL                                 | nREPL                         |
+| [CIDER][]        | nREPL + cider-nrepl middleware        | nREPL + cider-nrepl           |
+
+**inf-clojure** sits closest to the metal: it runs a Clojure (or babashka,
+Planck, …) subprocess under Emacs's [`comint`][comint] and parses its
+plain-text output.  Helper commands like documentation and arglist lookup are
+implemented by sending predefined code snippets to the REPL and reading what
+the REPL prints back.  Universal and cheap — but the lack of structured output
+means the editor can't always tell apart a return value, stdout, and an error.
+
+**Port** is one rung up.  prepl is a tiny TCP protocol that ships with Clojure
+itself; instead of plain text it emits tagged EDN messages (`:ret`, `:out`,
+`:err`, `:tap`, `:exception`).  That structure is enough to build reliable
+tooling on top, once you add a small bootstrap form for request/response
+correlation (see [`doc/design.md`](doc/design.md)).  Helper commands are still
+implemented by sending Clojure forms — same idea as inf-clojure — but Port
+can tell which response goes with which request without scraping prose.
+
+**monroe** is another rung up.  It uses [nREPL][], whose protocol provides
+sessions, ops, and request ids out of the box.  The editor side stays small
+because nREPL gives it those primitives for free.  No middleware required
+beyond plain nREPL.
+
+**CIDER** is the maximalist rung: nREPL plus the [cider-nrepl][] middleware
+suite plus a substantial editor codebase.  The middleware provides
+server-side support for features that aren't cheap to build on bare nREPL —
+debugger, inspector, test runner, profiler, structured stacktrace browser,
+refactoring.  Heavier setup, vastly more features.
+
+A useful way to read the ladder: **the bulk of each project lives wherever its
+protocol has the gaps**.  inf-clojure is small because `comint` already
+exists.  monroe is small because nREPL already gives it primitives.  Port has
+to be slightly bigger than monroe — the two-socket model, the bootstrap —
+because prepl gives it less.  CIDER's bulk mostly isn't even Emacs Lisp; it's
+`cider-nrepl`, server-side, because that's where nREPL is meant to be
+extended.
+
+Pick the rung you actually want: maximum power → CIDER; small structured
+client over prepl → Port; small client over nREPL → monroe; zero server-side
+requirements → inf-clojure.
+
+[inf-clojure]: https://github.com/clojure-emacs/inf-clojure
+[monroe]: https://github.com/sanel/monroe
+[CIDER]: https://github.com/clojure-emacs/cider
+[nREPL]: https://nrepl.org
+[cider-nrepl]: https://github.com/clojure-emacs/cider-nrepl
+[comint]: https://www.masteringemacs.org/article/comint-writing-command-interpreter
+
 ## Architecture
 
 prepl has no built-in request id, so any tooling that needs to know which