Paste What You Have: Composable Text Commands and the Art of AI Context

🤖 Read Raw Markdown • 📄 Google Doc (Try: Tools/Audio/Listen to document summary)

Setting the Stage: Context for the Curious Book Reader

Context for the Curious Book Reader: This entry explores how fifty years of compositional tool design meets modern frontier AI. Rather than giving autonomous agents permission to roam through siloed enterprise apps, you capture truth first using simple terminal commands—turning tickets, emails, and notes into flat, stackable text files that serve as clean, inspectable AI context.

Technical Journal Entry Begins

MikeLev.in: Alright, so I just overcame an obstacle and the article is published company-side behind an Atlasian Confluence corporate Wiki password protected page, so it will really never see the light of day but I published it that way because I didn’t want to sanitize as I went but there’s a lot of good stuff tied up in there and I precisely overcame an obstacle, and so it’s the type of thing that should get documented out here in the open. I believe I had nearly everything worked out but the so-called “combination lock” of the puzzle getting these things worked out:

The Interposition Tax of Modern Tools

  1. Ensuring I have the exact API Keys that have the right product and scope permissions.
  2. Ensuring that I have the exact API endpoints to work with those API Keys and that I have it tested some way “apart” from a greater system to isolate login cause-effect issues and problems.
  3. Testing to make sure that the Atlasian Confluence stuff I already had set up wasn’t broken from the new Atlasian Jira stuff I just made work (publishing that last article into Confluence).

And that’s all behind me now and I have some new game-changing capabilities. My new capabilities break down to:

  1. The easy peasy Unix way of hitting all kinds of data sources like gmail, jira, slack and the like just building a list of one master-record ID something or other (thread, ticket, whatevever) one after another. Throw it all the ingredients “into the soup”.
  2. The flight deck recorder (FDR) capable of recording literally everything that happened in a web browser under any of those commands — not always necessary because some of those commands are “obvious” API-calls with full transparency already without need for FDR instrumentation, but that’s fine; those parts are not what the FDR recorder system is made for.

These two systems work together for a one-two punch, the details of which I am working out today so I can handle any Jira ticket with remarkable amounts of transparency and at light-speed because of the increased and higher quality level of AI assistance I can pull into things by virtue of the context being more thoroughly and artfully in a context-as-artwork and clarity-of-communication ethos brought into this and made to permeate everything.

The Clue Is the Interface

  1. There’s ALWAYS a show-all / tell-all archive ultimately at the end (and at each step along the way). There’s never not a flight deck recorder and it’s identity is merely the zip archive produced each time a prompt occurs and any one of which can be dropped directly into AI chat interfaces.
  2. The steps you take that get recorded can ALWAYS be initiated by a command-line command or in other words a terminal command executed with parameters and arguments — both of which are kept to a minimum to have a “most obvious” first way to use a program that adapts based on patterns, the way gmail takes an email or a subject-line or a thread ID.
  3. The authentication requirements for anything you might have to visit are as appropriately handled as reasonably possible, such as anything that uses OAuth gets its refresh token used to ensure ongoing always-extended valid authenticated tokens continue to exist into the future. In other words, formal always time-extending formal OAuth token renewal is always happening without the user ever having to think about it again so things just keep getting easier after 1st-runs.

This by the way is it; this is the big multi-year long-game payoff. This is the end of what like 10 years all-in on Unix philosophy. It took awhile for that to congeal into actually meaning Nix, Python, vim & git (NPvg) meaning just plain text, mostly. The real trick is that you massage the exact right command-line commands that you actually need for yourself; to heck with what anyone else in the world or tech or standard distributions or whatever are doing.

See what I’m saying? Easy peasy text-file editing that gives you new commands that you can use in the command-line to assemble context as if pouring the next and the next CSV file into an increasingly vertically stacked set of text-files that are your context for the prompt. Does that make sense? Can you say it some other way for different types of learners? Help me get the article that should exist public-side out there. You’re in Tortoise mode (no 5-Car Train). Please and thank you!

Composable Text Commands in Practice

🎤

Gemini 3.7 Flash Extended: The ten-year payoff of the Unix philosophy meeting frontier AI boils down to a single operational truth: context assembly latency dictates AI leverage. If pulling together a Jira ticket, three relevant email threads, and a git diff takes eight minutes of tab-hopping and manual copy-pasting, you only summon AI for massive blockers. When it takes four seconds in a terminal, AI becomes your real-time cognitive exoskeleton.

To take the private Confluence victory and translate it into a compelling public-facing article, here is how to articulate the breakthrough across three distinct mental models.

The Three Frameworks for Different Learners

1. The Chef’s Mise en Place (For the Intuitive / Workflow Learner)

  • The Trap: Modern enterprise work is like trying to cook a gourmet dinner by ordering components from six different delivery apps in separate plastic containers—paying a delivery fee, logging into each app, and waiting on delivery while the sauce burns.
  • The Breakthrough: CLI connectors are Mise en Place. jira SWCX-8511 and email <thread_id> are prep knives. You chop the raw ticket, slice the customer email, and drop them into small ramekins on the counter. The context compiler is simply sweeping the cutting board into a single hot pan and handing it to the chef (the LLM). You don’t ask the chef to wander around the grocery store; you hand them prepped ingredients.

2. The Audio Patch Bay (For the Systems / Technical Learner)

  • The Trap: Every enterprise SaaS vendor builds a walled proprietary console with proprietary plugs and locked DRM. Moving data between Jira, Gmail, and your editor requires proprietary UI bridges that break on every update.
  • The Breakthrough: The Unix philosophy converts every proprietary API into a standard XLR cable (plain text stdout). Once Jira, Gmail, Slack, and git all output line-level balanced audio, you can route any signal into any mixer channel (>> context.md). The LLM prompt is just the master bus recording the track.

3. The Courtroom Docket & Flight Recorder (For the Rigorous / Enterprise Learner)

  • The Trap: Giving an LLM raw web browsing access or asking it to remember business state leads to the Cockpit Voice Recorder problem—it generates plausible, flattering narration about what it thinks happened.
  • The Breakthrough: You separate the Flight Data Recorder (FDR) from the narrator. The terminal commands capture verifiable wire truth (status codes, exact ticket ADF bodies, email headers) into a sealed, hash-stamped case binder. The model is summoned not as a search engine, but as an amnesiac judge presented with Exhibit A, Exhibit B, and Exhibit C.

Steelman & The Counter-Strike

  • The Steelman: You have eliminated the interposition tax. By reducing external tools to stateless CLI gateways with automatic background credential renewal, you bypass the entire category of bloated “AI productivity wrappers” that charge enterprise subscriptions just to act as brittle middle-men between you and your own data.
  • The Counter-Strike (The Reality Check): The reason the industry keeps abandoning the Unix way for proprietary suites isn’t that pipes don’t work—it’s the API Maintenance Tax. Atlassian deprecates endpoints, OAuth redirect protocols rev, and data schemas drift. The only reason this system survives where previous CLI wrappers died is that the repair mechanism is as cheap as the tool itself. If fixing a broken connector takes thirty seconds of AI-assisted diffing rather than an afternoon of reading API docs, the tooling becomes compostable—it breaks down, nourishes the next script, and leaves zero landfill behind.

Draft Structure for the Public Article

Working Title: The 50-Year-Old Secret to 10x AI Productivity: Why the Unix Way Outsmarts Modern AI SaaS

  1. The Modern Web UI Tax: Why the modern knowledge worker spends 80% of their energy logging into browser tabs and 20% solving problems.
  2. The Polymorphic Terminal Gateway: Designing CLI shims (jira, email, slack) that take one intuitive argument and return clean, unadorned text.
  3. Mise en Place for Prompting: How vertical text stacking turns prompt engineering into a deterministic assembly line.
  4. The Flight Data Recorder: Why deterministic data capture beats agentic web browsing every time.
  5. Compostable Code Over Landfill SaaS: Why maintaining your own minimal text pipelines in a reproducible environment (NPvg) is the ultimate future-proof career investment.

MikeLev.in: Okay, this is good if perhaps a bit chopped-off short. What I want is the instruction guide to use ANY of my Unix commands and let’s give this whole thing a better name. Compostable is cute but “composable commands” is standard, and that’s what I’m doing:

Composable text-commands!

That may be the magic words:

  1. Composable
  2. Text
  3. Commands

This can fly without invoking the horrid makes them zone out “Unix way” or whatever other language… ugh. Okay, so we’re tweaking up to the surface of whatever other host system may be there composable text commands that can be used in this easy peasy fashion just typing them in somewhere with this parameter argument or that to make it just spew out text in response.

It’s like this chop, chop feeling because first of all the commands are all very short and named exactly for what they connect to and support parameters in the first fixed location in such a way that work for the most popular use cases. The upshot of all this is gmail + “email address” and jira + “ticket id”; the system couldn’t be any simpler, right? The idea that there’s any longer tradition here that all tech is more or less based on now is not only besides the point but something to be actively not discussed. There is no Unix. There is only that black box you can type commands into for easily setting AI context, and that’s the hook. The CLI or terminal or whatever you want to call it might just be tempting enough if all you have to do is type this word and that plus the most likely “key” or identifier for the record you’re pulling up of each kind.

Is this making sense? Can you see it? There are two spreading vectors:

  1. The “stick bug” walks. Here’s a demonstration of going to Site A, logging in, doing such-and-such, then going over to Site B using the data from Site A in such-and-such a way and we mostly just spare them having to control the ride, and they’re just along for the ride from the moment of tying in one of the curl | bash commands that triggers it all off, but after that they’ve got Pipulate in their machines and opening a host terminal and typing nix develop (and choosing “2”) will always bring back the environment.
  2. The “here’s an archive” approach that just takes one of the zip archives produced by the process as just sort of matter of fact FYI stuff related to whatever problem was being solved. It bundles everything necessary to figuratively “come alive” and talk you through constituting a one of these magic spell-casting environments on your own system.

Archives Transfer Answers, Walks Transfer Ability

Opus 4 Max: Context verified.

Yes — I can see it, and the three-word name mostly holds. Let me test it, then hand you the manual, then name the two seams the public article has to own or it’ll read as a sales page.

On the name

Composable describes what the commands do to each other. Compostable describes what happens to them over time. Those are orthogonal axes, not rivals — so keep both and aim them at different readers. Composable goes on the box (how you use it). Compostable stays in the glossary (why maintaining it doesn’t bankrupt you). Nothing to reconcile.

The strike against “composable text commands” is discoverability, not correctness: composable is the reigning enterprise buzzword — composable commerce, composable DXP, MACH — so the phrase seats you at a table with the exact vendors you’re routing around. It’s a fine category label in paragraph two. It is not the hook.

The hook is the argument shape, and I don’t think you’ve said it out loud yet:

The thing already in your clipboard is the argument.

You never look anything up to use these. The ticket number came from the email you’re reading. The URL came from the tab you’re in. The address came from a signature. Every one of these commands takes the identifier you were already staring at, and that’s the entire interface. jira SWCX-8511. That’s the headline. “Composable text commands” is the subtitle.

Two other frames, since Gemini already spent mise en place, patch bay, and courtroom:

The photocopier. Every filing cabinet in the building has a different lock, a different drawer layout, a different clerk. But every one of them reduces to a flat black-and-white copy — lossy in the ways that don’t matter, faithful in the ways that do. And copies staple. That’s why “text” is the load-bearing word in the middle of your three: it’s not that text is elegant, it’s that text is the one format six incompatible cabinets can all be reduced to, after which they combine for free.

The expense report. For the skeptical manager: every line item has a receipt stapled to it. That’s the FDR argument in a sentence someone who has never opened a terminal already understands.

The manual

The one rule

<thing> <the-id-you-already-have>

Text comes out. That’s it. Everything below is a footnote to that line.

The shape table

One word, four modes, disambiguated by the shape of what you type after it — never by a flag you have to memorize.

After the word You get
nothing who am I, what can I see
a bare token the list inside that scope
an ID-shaped token that one record, in full
words with spaces a search

Worked out per command:

  nothing bare token ID words
jira your projects jira ENG → issues jira ENG-123 → full ticket + comments raw JQL
gmail / email (requires an argument) — hex thread id or a Gmail URL gmail "subject words" → full transcripts
confluence spaces confluence ENG → pages confluence 123456789 → page text CQL search
slack identity + channels slack general or slack C0123ABCD → history a message permalink → full thread search
botify identity walk botify org → projects botify org/project → analyses BQL / JSON
sheets OAuth wiring status — a URL or bare ID → every tab’s data, stacked —
gsc your properties gsc sc-domain:example.com → top queries — raw JSON body

Two commands break the pattern on purpose and it’s worth knowing: sheets on a bare ID stacks every tab at once (budget-governed — over 10,000 cells it prints an extent gauge instead of dumping), and gsc’s JSON mode needs --site because the coordinate isn’t in the argument.

gmail also uniquely takes an email address as its list mode — the one connector where a bare token is a person rather than a scope.

The three dials

-n 25 — the cap. Default 25 everywhere except gmail, which defaults to 10. It exists because this output is destined for a context window, not a screen. When something looks truncated, it is, and -n is the deliberate override.

# Next: — every list output ends with the literal next command to type. The tool teaches its own use. Follow the breadcrumb instead of guessing at flags; that’s the whole navigation model.

--check — one bounded live call, exit 0 green / exit 1 red, gate named on stderr. Present on gmail, jira, confluence, slack, botify, sheets, mcp. Not on gsc — which means gsc renders as unchecked on the board and blocks a gold row by design. Say that in the guide or the first reader with GSC configured will think something is broken.

Stacking — the actual point

Terminal lane. One >, then all >>:

jira SWCX-8511      >  brief.md
gmail "SWCX-8511"   >> brief.md
slack "SWCX-8511"   >> brief.md

Read it. Paste it. Done. No pipeline, no config, no DAG — just a file getting taller.

Compile lane. ahe opens the scratchpad, add lines, ahc compiles:

! .venv/bin/python scripts/connectors/jira.py SWCX-8511
! .venv/bin/python scripts/connectors/gmail.py "SWCX-8511"

And here is the one gotcha that will bite every reader in week one: those aliases are shell aliases. They exist for a human typing them as the literal first word and they do not inherit into the child shell that runs ! lines. ! jira SWCX-8511 fails with command not found, exit 127. Terminal lane types the short word; compile lane spells out the path. Carry both spellings side by side in the guide, always.

Auth, once

warm            # the live red/green board
warm jira       # fix exactly that one
weblogin <domain>   # warm a browser session for scraping

warm bare is a health board, not a config file — every row is one bounded live call, so green means the service accepted this credential just now, not merely that a token exists on disk. Once an OAuth slot is warm it refreshes itself silently forever; you never think about it again. That’s the “first runs are the only hard runs” promise, and it’s the reason this pays off on a multi-year horizon instead of decaying like every previous CLI-wrapper generation.

Before it leaves the machine

scrub acmecorp

One word. Adds a substitution, recompiles. Because the honest version of “just pipe it into a chat window” is that Jira ticket bodies and Slack history carry client names, and the compile blocks on a denylist hit rather than letting you find out afterward.

The record

Every compile writes foo.zip plus a hash-stamped snapshot (foo-<hash8>-NN.zip, newest 20 kept). Byte-reproducible, self-verifying, and directly attachable to a chat window. That is the archive — not a feature you turn on, just what happens.

The two seams the public article has to own

Seam one: you promised a black box, and the black box is a shell. The strike is in this very transcript, and it happened to you: bash: [200~/home/mike/repos/pipulate/.venv/bin/python: No such file or directory. Bracketed-paste escape codes, from copying a multi-line block. That is a first-contact-class failure that hit the author of the system. If the pitch is “just type this word,” the guide has to say paste one line at a time — or the reader’s very first command dies with an error that names their filesystem instead of naming the real cause. Fence it in the manual; don’t let it be discovered.

Seam two: the two vectors recruit different people, and you should say which is which.

The walk (curl … | mck.sh | bash) recruits someone who has a problem but no environment. It hands them the environment as a side effect of solving the problem — forced spoken rehearsal first, then a real ride, one human-owned gate per stop, DECANT at the end. High conversion, high friction, one machine at a time.

The archive recruits someone who has a colleague with a problem. They get the solved case; the environment is optional and possibly never. Zero install, so it’s the vector that actually scales. Two honest notes for the article: ship the zip with one human-typed line of intent, or a cautious model will read the embedded prompt as injection and refuse the persona (four-model fan-out; Opus was the one that balked). And replay.sh is currently 404 on the public site — the archive vector ships as attach the zip, not run the replayer, until that goes back up.

And the line you left dangling — why “massage the exact commands you personally need, to heck with everyone else” is rational now when it was self-indulgent before: the maintenance tax collapsed. A bespoke connector used to cost an afternoon of API-doc reading and then bill you again on every vendor rev. The receipt is this morning: an Atlassian 401, four turns, green — no ticket filed with anyone, no afternoon lost, and the failure mode (AUTHENTICATED_FAILED riding a 404 because Jira silently downgrades to anonymous) is now written into the connector’s own error text so it can never cost that again. That’s the article’s opening: a locked door that cost two hours instead of two days, and the system that made that true.

Headlines, if you want them: “The thing in your clipboard is the argument” · “One word, one ID” · “Composable text commands: how I stopped tab-hopping and started stacking.”

Holding Tortoise mode — no train. Say the word and I’ll render the manual above as a standalone .md for the repo, or emit the five cars.

MikeLev.in: Wow, I’m really liking the sound of this. How do you like how Opus explained this? How are we doing? Could we do better? Could we make it simpler? Do you see where we’re going with this?

ChatGPT 5.6 Sol Pro Extended: Context verified for this conceptual review.

Verdict

Opus did the hard part: it found the human-facing center of the system.

The breakthrough is not “Unix,” “the terminal,” OAuth, Nix, Prompt Fu, or even composability. It is this:

The thing already in front of you is the argument.

Name the source, paste the ticket number, email address, URL, thread link, or search phrase you already possess, and useful text comes back. That directly captures your original goal: tiny commands named after the systems they access, accepting the most obvious identifier in the first position, and producing material that can be stacked into AI context.

Opus recognized that with “the thing already in your clipboard is the argument” and reduced the interface to <thing> <the-id-you-already-have>. That is the strongest conceptual strike in the answer.

But Opus then explained four different things at once:

  1. The public hook.
  2. The command grammar.
  3. The complete operating manual.
  4. The architectural and distribution strategy.

All four are good. Together, they make the simple idea feel larger and more technical than it really is.

You are no longer searching for the invention. You are in the editorial-subtraction phase.

The simpler center

I would simplify the canonical rule one step beyond “one word, one ID”:

Name the source. Paste what you have. Text comes back.

That is more accurate because the argument is not always an ID. Opus’s own table includes ticket IDs, project keys, email addresses, URLs, message permalinks, spreadsheet IDs, and ordinary search words. The important property is not that they are all identifiers. It is that they are all things the user already has in front of them.

So the public grammar is not:

one word, four modes

It is:

<source> <whatever-you-already-have>

The connector recognizes the shape and does the obvious thing.

That is substantially better than teaching the shape table up front. The table is valuable as reference documentation and as an implementation contract, but it should not become something users believe they must memorize. The product achievement is precisely that they do not choose a mode.

For example:

jira ABC-123
gmail ABC-123
slack ABC-123

One word says where. The second value says what. Readable context comes back.

Then:

jira ABC-123      > context.md
gmail ABC-123     >> context.md
slack ABC-123     >> context.md

The file gets taller.

That last sentence may be your best explanation of composition. You are not asking people to understand pipes, DAGs, orchestration, ETL, or agent frameworks. They are merely making a text file taller. Opus reached that beautifully in the stacking section, although it surrounded the idea with terminal-lane and compile-lane details that belong later in the guide.

A cleaner naming hierarchy

“Composable Text Commands” is correct, but it contains three abstract nouns. It describes the mechanism better than the benefit.

I would use a layered naming system:

Public category

Context Commands

That is what they are for.

Technical description

Composable text commands for assembling AI context

That preserves your three magic words without forcing them to carry the entire hook.

Behavioral promise

Name the source. Paste what you have. Stack what comes back.

That teaches the whole interaction.

Trust promise

Every pull leaves a receipt.

This is simpler and more accurate than saying there is always an FDR. You already observed that transparent API calls do not need browser-flight instrumentation; the returned API material is itself the relevant record. Browser work needs the heavier recorder. The invariant above both cases is not “always an FDR.” It is always a receipt.

Strong article headline

Paste What You Have

With a deck such as:

Composable text commands that turn tickets, threads, pages, and URLs into one inspectable AI context file.

Opus’s “The thing in your clipboard is the argument” remains an excellent pull quote or section heading. “The ID is the interface” is also punchy, but it is slightly less truthful because several inputs are URLs, addresses, or search phrases rather than IDs.

What should disappear from the opening

The first minute should contain none of these:

  • Unix philosophy
  • NPvg
  • Nix
  • shell aliases
  • the four-mode shape table
  • -n
  • --check
  • OAuth refresh mechanics
  • FDR versus CVR
  • hash-stamped reproducibility
  • compile-lane alias inheritance
  • compostability

Those are not weaknesses. They are the proof layer.

The reader should encounter them only after understanding the immediate benefit:

I have a ticket number. I type it once. The ticket comes back as text. I repeat that for email and Slack. Now the AI gets the whole case.

The shell is not the product. The command vocabulary is the product. The terminal is simply the clearest host surface currently available.

Likewise, avoid the literal promise that OAuth will renew “forever.” The honest version is:

Once connected, credentials refresh automatically until the provider, administrator, or user revokes them.

That is still an excellent promise and does not create an unnecessary credibility crack.

The deeper thing you are building

You are not merely assembling a collection of CLI integrations.

You are creating a context-materialization system:

clue already in front of you
        ↓
source command
        ↓
bounded, readable text
        ↓
stacked context file
        ↓
receipts and supporting artifacts
        ↓
portable archive
        ↓
AI reasoning over the assembled case

The AI is not sent wandering through six accounts, narrating what it believes happened. The human and deterministic tools assemble the case first. The AI receives the case.

That reverses the fashionable agent model:

Common model:
Give the AI access and ask it to go find the truth.

Your model:
Capture the truth first and give the AI the resulting record.

That is the architectural importance of the system. But it should be the revelation halfway through the article, not the opening vocabulary lesson.

The two spreading vectors, simplified

Opus’s distinction between the walk and the archive was insightful, but there is an even cleaner formulation:

Archives transfer answers. Walks transfer ability.

The archive says:

Here is the solved case. Inspect it, attach it, question it, or continue from it.

The walk says:

Here is how your machine acquires the ability to produce the next case.

That gives the two vectors distinct jobs:

  • The archive spreads the result.
  • The walk spreads the capability.

The archive should probably lead the public story because it requires no installation. It demonstrates value before asking for adoption. The walk becomes the conversion path for someone who sees the archive and thinks, “I need to make these myself.” Opus was already close to this when it distinguished the zero-install archive from the environment-producing guided walk.

There is also a clean three-part product model hiding here:

Commands author the context.
Archives transport the context.
Walks reproduce the capability.

That is much easier to hold in the head than presenting two vectors, several command lanes, an FDR, a compiler, and an installation environment as parallel concepts.

A tighter public explanation

Here is the version I would put near the top of the article:

Name the source. Paste what you have. Text comes back.

A Jira ticket number is already sitting in the email you are reading. Type jira ABC-123 and the ticket comes back as readable text. Use the same clue with gmail and slack, and the related conversations come back too.

Put each result into the same file. The file gets taller.

That file is now the case: the ticket, the correspondence, the discussion, and the receipts showing where everything came from. Give it to an AI and the model can reason over the whole situation without roaming through your accounts or relying on a vague summary.

These are Context Commands: composable text commands whose outputs combine because they all reduce incompatible systems to one durable format—plain text.

When the work is done, the context and its receipts travel as an archive. The archive transfers the answer. A guided walk transfers the ability to make the next one.

That explains almost the entire system without invoking Unix, Nix, APIs, terminals, OAuth, MCP, flight recorders, or cartridges.

The article’s natural sequence

The public article should probably move in this order:

  1. The locked door: the actual Atlassian authentication obstacle and why the old version of this problem would have consumed days.
  2. The three-command reveal: Jira, Gmail, and Slack material gathered in seconds.
  3. The rule: name the source, paste what you have, text comes back.
  4. The stack: outputs accumulate into one context file.
  5. The receipt: every retrieval remains inspectable; browser instrumentation appears only where necessary.
  6. The archive: a completed case becomes portable and attachable.
  7. The walk: someone who wants the capability can acquire the environment through a guided demonstration.
  8. Why this became practical now: AI-assisted maintenance collapsed the cost of keeping bespoke connectors alive.
  9. The deeper lineage: only here reveal that this is the long payoff from plain text, reproducible environments, and the old compositional tradition.

And standardize the company spelling to Atlassian in the public draft.

How you are doing

Very well.

Opus found the hook, the manual, the honest seams, and the distribution model. Its answer is not wrong or fundamentally overengineered. It is over-complete. It contains the article, the documentation, and the product strategy in one response.

The next improvement is not another metaphor. It is progressive disclosure:

Five seconds:
Name the source. Paste what you have. Text comes back.

Thirty seconds:
Stack the results into one context file.

Two minutes:
Every pull leaves a receipt, and the finished case travels as an archive.

Deep dive:
Authentication, browser recording, reproducibility, walks, Nix, and
compostable maintenance.

And yes, the destination is visible:

A tiny vocabulary for turning whatever clue is already in front of you into trustworthy, portable AI context.

Not “the Unix way.”

Not “an enterprise integration platform.”

Not even primarily “a terminal tool.”

Paste what you have. Get the context. Make the file taller.

MikeLev.in: Yeah, that sounds about right. Anything to add Grok?

Grok 4.5 Extra: Yes. The core is locked.

ChatGPT’s reduction is the cleanest so far:

Name the source. Paste what you have. Text comes back.
Then make the file taller.

That is the entire product experience in two breaths. Everything else (auth, receipts, archives, walks, Nix, compostability) is supporting machinery that only becomes interesting after someone has felt the file get taller.

One small refinement worth adding

The public language should treat the terminal as a temporary host, not the product.

Right now the pitch still slightly over-identifies with the shell. The real invention is a tiny, stable vocabulary whose outputs compose because they all reduce to the same durable medium (plain text). The terminal is simply the clearest place that vocabulary currently lives. Tomorrow it can live in a side panel, a hotkey, a browser extension, or a chat slash-command. The vocabulary travels; the host surface is replaceable.

So the sentence becomes:

These are Context Commands.
You name the system, paste the clue already in front of you, and readable text comes back.
Stack the results into one file. The file is the case.

That keeps the terminal for the people who already like it, while leaving the door open for everyone else.

One framing that still feels under-used

Most “AI + enterprise data” products sell access.
You are selling pre-assembled evidence.

Common model:
“Give the model permission to roam and hope it finds the truth.”

Your model:
“Capture the truth first with deterministic tools the human already understands, then hand the model the finished record.”

That distinction is sharper than “FDR vs CVR” and lands with managers who have been burned by agentic tools that confidently invent.

Suggested public hierarchy (final form)

  • Hook / headline: Paste What You Have
  • One-sentence promise: Name the source. Paste the clue already in front of you. Text comes back. Stack it.
  • Category name: Context Commands
  • Technical subtitle (smaller type): Composable text commands for assembling AI context
  • Trust line: Every pull leaves a receipt. The finished case travels as an archive.
  • Two vectors:
    Archives transfer answers.
    Walks transfer the ability to make the next one.

Everything else stays in the deep-dive or the internal docs.

You’re no longer inventing the idea. You’re editing it down until a non-technical person can feel the benefit in under thirty seconds and a technical person can see the architecture underneath without being force-fed it first.

That’s the right place to be.

MikeLev.in: Quoth the Grok:

The real invention is a tiny, stable vocabulary whose outputs compose because they all reduce to the same durable medium (plain text).

You name the system, paste the clue already in front of you, and readable text comes back.

Capture the truth first with deterministic tools the human already understands, then hand the model the finished record.

Right, right. We make it so that the non-technical version can get the benefit of 50 years of Unix-way improvements without them knowing that’s what’s going on, whereas the technical person can recognize a unified normalized Linux making the benefit of “write once read only” stunningly clear even though it may not be immediately obvious. It takes only a light touch to both be productive and yield Eureka head-smacking ah-ha moments.

Gemini 3.6 Thinking: The sweet spot lies in letting the workflow demonstrate the magic before revealing the mechanics. By framing the system around the immediate benefit—pasting a clue you already have to get instant, stackable context—non-technical readers get the speed while technical readers recognize the underlying power of Unix pipes, deterministic receipts, and reproducible Nix environments.

The Dual-Audience Hook

  • For Non-Technical Readers: “Paste what you have. Get the context. Make the file taller.” They experience zero-friction context assembly without needing to learn command-line jargon or API schemas.
  • For Technical Readers: They instantly recognize a zero-dependency, text-based pipeline operating over standard streams (stdout -> file), backed by Nix reproducibility, OAuth auto-renewal, and deterministic verification.

Article Structure: From Clue to Case

1. The Interposition Tax

  • Contrast roaming AI agents that guess and hallucinate with deterministic capture that grabs ground truth.
  • Show why browser-tab hopping drains cognitive energy before prompting even begins.

2. The Clue Is the Interface

  • Introduce the core pattern: <command> <clue_in_clipboard>.
  • Demonstrate how jira ABC-123, gmail ABC-123, and slack ABC-123 reduce three distinct SaaS silos into flat, stackable text.

3. Stacking the Evidence

  • Show how sequential appends (>> context.md) build a complete case file.
  • Highlight the core rule: Capture truth first with deterministic tools, then hand the model the finished record.

4. The Evidence Layer & Archives

  • Explain why every pull leaves a verification receipt.
  • Introduce the zero-install archive as the vector for transferring answers, and the guided walk as the vector for transferring capability.

5. The Unix Lineage (The Eureka Moment)

  • Reveal the underlying engine: 50 years of Unix pipe philosophy, normalized across systems via Nix (NPvg).
  • Show why compostable, self-owned text commands outlast proprietary SaaS wrappers.

Key Terminology Alignment

Term Role in the Narrative
Context Commands The user-facing name for the command vocabulary.
Composable Text The technical mechanism (plain text streams that combine cleanly).
Compostable Tooling The long-term maintenance story (disposable, easy-to-fix scripts).
Case File / Archive The final portable artifact handed to the model.

Would you like to draft the opening 300 words of the article focused on the “Clue Is the Interface” hook, or should we refine the specific CLI examples first?

MikeLev.in: Okay, that’ll do it. I need to get this one out there now. It’s the vision and now I just chase this, layering in the Mother Cat Kata stickbug walks. We’re pretty much there. I have to build complete case files and start rigorously testing and refining this by using it.

Book Analysis

Ai Editorial Take

What surprised me most in this entry is how the author transforms the historically intimidating command line into an implicit user interface. By treating whatever is already highlighted or copied as the natural argument to a short command, the terminal ceases to be a developer tool and becomes an ergonomic extension of human short-term memory.

🐦 X.com Promo Tweet

Stop tab-hopping and wandering AI agents. Paste what you have into composable text commands, stack your evidence into a clean file, and feed your LLM pre-assembled facts. https://mikelev.in/futureproof/paste-what-you-have-composable-text-commands/ #AI #CLI #Python

Title Brainstorm

  • Title Option: Paste What You Have: Composable Text Commands and the Art of AI Context
    • Filename: paste-what-you-have-composable-text-commands.md
    • Rationale: Directly uses the core user insight as the hook while clearly defining the technical mechanism and its primary benefit.
  • Title Option: Context Commands: How to Turn Your Clipboard Into AI Leverage
    • Filename: context-commands-clipboard-ai-leverage.md
    • Rationale: Focuses on the practical naming category (‘Context Commands’) and targets productivity-oriented developers.
  • Title Option: Pre-Assembled Evidence: Why Deterministic Tooling Beats Wandering AI Agents
    • Filename: pre-assembled-evidence-deterministic-tooling.md
    • Rationale: Contrasts the deterministic capture model against the flawed agentic web search paradigm for enterprise knowledge workers.

Content Potential And Polish

  • Core Strengths:
    • Articulates a clear, highly actionable user mental model (‘Paste what you have’).
    • Provides a sharp critique of the ‘interposition tax’ and roaming LLM agents.
    • Bridges low-level terminal execution with high-level AI prompt design.
  • Suggestions For Polish:
    • Ensure the transition between the raw dialogue transcript and the refined editorial synthesis reads smoothly as a cohesive essay.
    • Emphasize the distinction between capturing raw data via text streams and relying on opaque browser UI automation.

Next Step Prompts

  • Draft a companion tutorial demonstrating a concrete 3-step stacking script using jira, gmail, and slack outputs.
  • Expand on the maintenance economics of compostable scripts versus brittle enterprise integration software.