DESH

history is amnesia

Command strings are half-remembered; timing and outcome context — the expensive part — is dropped entirely.

outputs burn on read

The result the machine just computed becomes unaddressable text. Want it again? Re-run it.

pipelines run blind

a | b | c is composed in your head and debugged by bisection. Stage two's output should be visible while writing stage three.

apps pretend to be paper

Every pager and TUI is a one-off interactive surface with zero affordances exposed to the system around it.

enter a resource

The default response to a path is the safe projection: type, listing, metadata, recency — what ls and stat were always circling.

plugins recognize types

Files, folders, processes, ports, repos, datasets — each mapped to a typed projection. A CSV is rows with a schema, not bytes that happen to print.

affordances over flags

The resource exposes its verbs in words — preview, edit, watch, diff, remove. cat and rm were names rationed by a teletype.

autocomplete is traversal

Completion expands nested affordances of the addressed resource — hypermedia navigation, not prefix matching.

code on demand

Recognizers and affordances ship as sandboxed WASM; the environment learns new types the way a browser learns new pages. Discovery rides an affordance registry in the spirit of mamund's GRAIL: the CSV that realizes it needs a viewer, finds a wasm csv-tui, and runs it sandboxed — acquisition logged, revocable.

sourcesmamund/grail-public

incremental pipelines

find | grep, but you grepped wrong — fix the grep and replay find's buffered output instead of re-walking the disk. Matching is interactive (fff-style, as adopted by opencode), and stages get durable-execution semantics: resume from offsets, recompute only what changed.

terminals assume a desk

SSH on a phone is the same incantations with worse ergonomics — scrollback you can't search, flags you can't tab-complete, soft-keyboard muscle memory for syntax nobody should memorize on a bus.

IDEs ship the whole workshop

Desktop IDEs bundle editors, debuggers, extensions, and language servers. Mobile ports shrink chrome and keep the weight — or become read-only viewers. You don't want the whole workshop in your pocket.

affordances are taps

Hypermedia is closer to touch than teletype: enter a resource, read a typed projection, choose a verb from what's offered. Entry chips, approval buttons, a tree you tap to enter — not a monospace void waiting for incantations.

code-on-demand is the mobile install model

Discover what the resource needs; fetch a sandboxed recognizer — hash-identified, logged, revocable. A CSV loads a WASM table viewer for this session, not an IDE extension pack. The browser's lesson applied to the operating surface.

sessions travel as links

Ledger-backed sessions share as replay URLs — history and fingerprints, never tokens. Inspect staging from a phone, approve an agent effect between meetings. Mobile as triage and audit, not a second-class terminal emulator.

composition still wants a keyboard

Pipelines, long edits, and heavy typing remain desk work — honestly. The claim isn't that phones replace terminals; it's that inspect, navigate, approve, and replay shouldn't require one.

channels, not stdout/stderr

Line-prefixed named streams for arbitrary outputs and inputs. POC built: stream in/out against s2.dev as a replayable buffer — late consumers attach and read from an offset, the webpoke doctrine applied to process I/O.

sourcess2.dev

POSEVEN

Content-addressed store + append-only oplog: one transaction applies many mutations, checkouts are pointer moves (no watcher churn), forks are O(1), and an in-memory projection spares the SSD. POSEVEN — the one after POS-six. Tagline: all you need is log (AYNIL).

a declarative strangler

Optic's move at the CLI boundary: observe invocations, accrete help/flags/types as data, and replace incantations with typed affordances verb by verb — lifting wrapped tools' stdout/stderr into structured channels along the way.

agentic sandboxes

Ledger + CAS fs + named channels is the substrate agents need: fork per attempt, replay as audit, grant verbs not paths.

unbundle the servers

Dev, CI, and app servers are three computers re-deriving the same outputs with incompatible caches. On a content-addressed substrate they become memoized nodes of one computation graph, rebundlable onto fewer machines — CI is the graph with stricter provenance; the dev server is the graph with a watcher.

the pipeline-to-prod pipeline

An exploratory pipeline is already a typed dataflow object, so promotion to production is an affordance, not a rewrite: name it, pin inputs, parameterize literals, attach a schedule, ship the same graph — under whichever scheduler and output engine fits: local incremental, durable-execution, batch orchestrator, stream processor; TUI, dashboard, file, or service. desh spots the candidates — the one-liner you've re-run fourteen times is asking.

field cards (via rhett)

Filed by hand against this page: Kreps' 2013 log essay (the AYNIL ancestor), Rama's depots and PStates (AYNIL at industrial scale), Temporal and Azure Durable Functions (the engines pipeline-to-prod targets), direnv (the prompt is a place, folk edition), and nix (POSEVEN's instincts behind a grammar people refuse to learn). The full tray renders on the Rhett page.

exit status was the MVP

One byte was all POSIX let a process say about what it computed. $(command) substitution is the confession: we wanted values; we got text and a parser.

declared at the boundary

A command's boundary description declares its outputs — or the strangler observes them. deploy exports $deploy.url, $deploy.version, $deploy.took; the next command references them by name. No capture ceremony, no eval.

CI already proved the demand

GitHub Actions reinvented process outputs as a temp-file convention ($GITHUB_OUTPUT) because the shell never shipped them. desh makes the pattern native: typed, declared, completable.

composition beyond the pipe

A pipe composes two adjacent processes once; variables compose the whole session. Any command references any prior result by name — dataflow across time, and the session starts behaving like a notebook whose cells are commands.

variables are ledger facts

Typed, timestamped, provenance-linked to the invocation that produced them; replay restores them. An agent reading the session reads $deploy.url, not scrollback regex.

organizational replay

"How did this system get into this state" becomes a query over the ledger.

docs that execute

Examples are live objects with provenance, not copy-paste fossils.

handoff without loss

A session hands to a colleague — or an agent — as structure, not a screenshot of green text.

Warp

Modernized the chrome — blocks, real editing — and kept strings-over-hidden-state underneath.

Fig

Proved the appetite for affordances as an overlay; bolted onto strings, acquired by Amazon, sunset.

nushell

Structured pipes are the right instinct, inside a forgetting shell with a new grammar to memorize.

Jupyter

Keeps outputs — and proves how much that alone is worth — but it's a document about computation, not an operating surface.

*sh

A shell-like thing that knows its lineage: sh, bash, zsh, fish — desh.

d-e-sh

Developer Environment SHell. The acronym is the spec.

desh as home

In several South Asian languages, desh is home — and home was always ~. The tilde is load-bearing: the prompt is a place, not a void.

developer exhaust

DE also reads as developer experience — and developer exhaust. Shells discard the most valuable exhaust a DX team could wish for; desh captures it by default.

Sgittish

A repo-level object store drafted long before the lab: an append-only ledger of codebase facts — command history, profiling, issues, dependency changes — consumed by simpler, more powerful editors. Never built; its ledger became desh's session ledger and its store became POSEVEN.