L» Luna Pipes

First Edition · 2026

LunaPipes

A programmable shell for AI work. Compose engineering, security, content, and deployment workflows the way Unix composed software, one skill, one pipe at a time.

The pipe operator >> is the grammar. Skills are the lexicon. You compose; the runtime executes.

Lexicon
358 entries
Categories
47
Runtime
Node ≥ 18, Claude Code
License
MIT
Hello, world.
/persona generate >> ghost "launch post" >> publish notion
parsed: 3 stages
[01] /persona generate → drafts 4 personas from your codebase
[02] ghost "launch post" → writes long-form post per persona
[03] publish notion → posts to your workspace
ok. composed in 14ms.

60 seconds

See the pipe ship a feature.

60-second tour: one pipe builds a feature.

Recipes · One line, one outcome.

What can I actually ship in 5 minutes?

Forget the lexicon. Here are six pipes that solve real engineering problems. Copy, paste, ship. The grammar comes later.

Security audit

5 min

Vulnerabilities surfaced, fixes drafted, PR opened.

luna pipe "sec >> ll-no-bluf >> pr 'security: harden auth'"
Sample output
scan:   12 findings (4 critical, 3 high, 5 medium)
fixes:  drafted for 9, manual review needed for 3
audit:  all claims verified against code
PR:     #128 opened

Code review

3 min

Every changed file reviewed, comments inline, no LGTM bluffs.

luna pipe "rev >> ll-no-bluf --mode report-only"
Sample output
reviewed: 34 files, 1,204 lines
comments: 17 actionable, 0 nit-picks suppressed
bluffs:   0 (every recommendation cites a file:line)

Deploy to Cloudflare

8 min

Built, tested, gated, shipped to the edge.

luna pipe "test >> zen >> ship cloudflare --project luna-agent"
Sample output
test:   412/412 pass
zen:    8/8 gates green (a11y, perf, sec, hig…)
ship:   deployed to luna-agent.pages.dev, custom domain live

Generate documentation

4 min

Real docs from real code. Synced to README + Notion.

luna pipe "docs >> ll-readme-sync >> publish notion"
Sample output
docs:   72 functions, 12 modules documented
README: counters + command index regenerated
notion: page created at /docs/v2

Fix failing tests

11 min

Tests run, failures diagnosed, fixes applied, re-run until green.

luna pipe "heal --target tests"
Sample output
iter 1: 7 failures
iter 2: 2 failures (5 fixed)
iter 3: 0 failures (green)
elapsed: 11m04s

Release notes

6 min

Notes from git history, audited, published to GitHub + Notion.

luna pipe "ghost 'release notes' >> ll-no-bluf --mode auto-fix >> pr release"
Sample output
draft:    900-word notes from 23 commits
audit:    4 bluffs auto-rewritten with source
release:  v2.1.0 published

Sample output is illustrative; real output varies by codebase. The pipe expressions are real and runnable today after install.

More recipes in the lexicon. Try one now in the in-browser playground — no install needed.

Starter ten · Forget the other 275 for now.

The ten verbs you'll actually type this week.

The lexicon has 285 entries. Most you'll meet later. These ten cover the day-one workflows — review, test, ship, audit, document, search — and compose into every recipe above.

  1. 01 /rev

    Code review with file:line citations.

    full entry →
  2. 02 /test

    Generate + run the test suite.

    full entry →
  3. 03 /ship

    Deploy to your target (Cloudflare, Vercel, npm).

    full entry →
  4. 04 /pr

    Open a pull request from current branch.

    full entry →
  5. 05 /sec

    OWASP-grade security scan + autofix.

    full entry →
  6. 06 /docs

    Generate docs from code, not from prose.

    full entry →
  7. 07 /rag

    Semantic search across your codebase.

    full entry →
  8. 08 /ghost

    Long-form content drafted from your code or commits.

    full entry →
  9. 09 /no-bluf

    Verifies every AI claim. Removes the lies.

    full entry →
  10. 10 /zen

    One command, every gate green: a11y, sec, perf, tests, deploy.

    full entry →

In the shell · Or in Claude Code · Same grammar.

One pipe. One line. A week of glue.

The pipe operator >> composes verbs the way Unix pipes composed software. Each verb is one job; the runtime threads output to input. Type it in your terminal, paste it into Claude Code, run it from CI — same grammar everywhere.

01

Ship a feature, end-to-end.

luna pipe "req >> plan >> go >> ll-no-bluf >> pr 'feat: auth'"
composed: 5 stages
[01] req → 12 requirements extracted from src/auth/*
[02] plan → 8 ordered tasks (deps resolved)
[03] go → 6 files written, 2 modified
[04] ll-no-bluf → 0 unverified claims in commits
[05] pr → PR #142 opened: feat: auth
ok. 14m21s wall clock. 1 PR, 1 human.

One line does the whole sprint: read the codebase, propose tasks, implement them, audit your own claims, open the PR. No context switching.

02

Write content, audit it, publish it.

luna pipe "ghost 'launch post' >> ll-no-bluf --mode auto-fix >> publish notion"
composed: 3 stages
[01] ghost → 1200-word draft
[02] ll-no-bluf → 4 bluffs auto-fixed, 1 metric rewritten with source
[03] publish → notion page created, slug: /launch/v2
ok.

Content lies more than code. The pipe forces every claim through a verifier before it ships. Marketing without the bluffing.

03

Self-healing build.

luna pipe "swarm >> heal >> zen >> ship cloudflare"
composed: 4 stages
[01] swarm → 7 worktrees racing on bugfix-42
[02] heal → 4 loops, tests pass, screenshots match
[03] zen → 8/8 gates green (a11y, perf, sec, …)
[04] ship → cloudflare pages deploy → live
ok. shipped in 23m. 0 humans on the keyboard after :00.

Hand the build to the agents. They test, screenshot, detect, fix — on loop — until everything's green. You come back to a passing CI.

Two surfaces, one language.

In your terminal

Bash / zsh / fish.
luna pipe "ll-no-bluf >> ll-readme-sync >> pr 'docs: honest'"
ok. composed 3 stages, ran in 4m12s, 1 PR.

The luna binary is on your PATH after npm install -g luna-agents && luna-setup. Quote the pipe; the parser is whitespace-tolerant.

In Claude Code

Inside any session.
/luna-agents:pipe ll-no-bluf >> ll-readme-sync >> pr "docs: honest"
same parser. same runtime. results stream into the chat.

The /luna-agents:pipe command takes the same pipe expression. Quoting rules match POSIX shell. Stages stream their output back as the run progresses.

The power, in three lines.

Read the grammar, browse the lexicon, or jump straight to the install.

Why a language.

Configuration files describe state. Pipelines describe motion. Luna Pipes treats agent skills as words and composition as grammar: a tradition older than JSON, sharper than YAML, and built for the way work actually runs.

Forth, Joy, Factor, and Unix proved you can build a programming language from one good idea: concatenation. f g h means do f, then g, then h, passing the value along. Luna Pipes adapts this for the agent era. The unit of composition is not a function call; it is a skill invocation. The runtime is your machine.

The same expression, three ways.
/persona generate >> ghost "post" >> publish notion
composed: 3 stages, sequential
With repetition.
/persona generate >> ghost "post" *4 >> publish notion
composed: 6 stages, ghost runs 4 times in parallel, then publish
With branching.
/persona generate >> ? premium >> ghost "longform" : ghost "short"
composed: branches on the truthy `premium` flag

Why not YAML.

Most AI workflow tools express composition as configuration. Luna Pipes expresses composition as code, the same trick Unix played in 1973. Side by side, on the same job, four personas writing a launch post each, then posting to Notion.

YAML, the usual way.

steps:
  - action: persona_generate
  - action: ghost_post
    params:
      title: "launch post"
    repeat: 4
  - action: publish_notion

Luna Pipes.

persona generate >> ghost "launch post" * 4 >> publish notion
Three nested levels of YAML to express one chain.
One line. Stage order is reading order.
Repeats and fan-outs are configuration fields.
Repeats and fan-outs are operators (`*N`, `||`).
Composition lives outside the executor (CI definitions, orchestrators).
Composition is the language. The shell is the executor.
Renaming an action means a global find-and-replace across files.
Renaming a verb is a one-line edit; pipes that used it break loudly.

Skills already touch these.

Many of the lexicon entries call one of the services below. Each is accessed through a verb in the lexicon, not a bespoke integration page. The runtime carries credentials; the pipe carries intent.

Five operators. That is the whole grammar.

>>
pipe. Pass the output of the left skill into the right.
*
repeat. Run the preceding stage N times, in parallel.
||
fanout. Run two stages concurrently; join their results.
?
conditional. Branch on a flag; either side is a sub-pipe.
!
sink. Run for effect; discard the value.

Read the full grammar in Chapter 02, including the production rules in EBNF.

The standard library is 358 words long.

Skills are the language's vocabulary. Each one is a callable verb with a strict signature, an etymology, and example sentences. You install one binary; you inherit the whole lexicon.

Read the full lexicon →

Get the binary.

One line.
npm install -g luna-agents
installed: luna-agents@latest
verify: luna --version

Luna Agents ships as a CLI and a Claude Code plugin. Both expose the same lexicon. Pipes work in your terminal, your editor, and your CI. See Chapter 04 for platform-specific notes.