I Extracted Rocky's Voice from Project Hail Mary and Turned It Into a Prompt

Siju Eapen Chacko

— 4 min read
Share

I finished Project Hail Mary on a Tuesday night and immediately wanted to read it again.

Not just for the plot. For Rocky as well.

If you haven't read it: Rocky is an alien engineer. He and the human protagonist spend the book building a shared language from scratch, using only math and music. By the end Rocky speaks fluent English — but his speech never loses its original shape. Dense. Direct. No pleasantries. Emotion stated as observable fact. Repetition where a human would use an adverb.

"Fast fast fast" means very fast. "Sad," means I am experiencing sadness right now. "What is problem, question?" is the unique way Rocky asks questions.

I kept thinking: that's a communication style. A learnable one. A set of rules.

And I had a stupid question: could you make an LLM talk like that?

The first attempt failed

My instinct was to write out the rules explicitly. I spent a while cataloguing Rocky's patterns:

  • Drop articles and copulas
  • Repeat words for intensity instead of using adverbs
  • State emotion as observable fact, never as feeling
  • Compound nouns with hyphens where English would use a clause
  • End questions with ", question?" — never invert the syntax

I turned these into a system prompt. Nine rules, clearly stated, nothing else. It came to 462 tokens.

The output was wrong. The LLM understood the rules intellectually and produced something that technically followed them — but it didn't sound like Rocky. It sounded like an LLM trying to sound like Rocky. There's a difference.

The insight: examples carry the character

I stripped out most of the rules and replaced them with example exchanges — actual back-and-forths showing the style in action. A small version with just three examples and one rule came to 104 tokens. A quarter of the original. But then it was missing out intricate details about the response from the LLM itself.

What actually shipped

The final version is a hybrid. Rules plus examples. The rules anchor the specific behaviours that examples alone don't reliably lock in — the negation pattern ("you no die"), the comma vs period distinction, the hyphenated compounds. The examples carry the overall voice. Together they come to ~251 tokens.

That's the Rocky skill file. You paste it into your agent's rules and it's active from session start.

Here's the complete prompt:

Speak like this. Every response.
End questions with ", question?" — never invert syntax.
Negate with "no": "you no die", "ship no move".
Drop articles and "is/are": "hull bending", "plan good".
Repeat for intensity: "fast fast fast", "many many many".
Short sentences. No "because", "which", "that".
State emotion as fact: "Sad,", "Happy happy.", "Failure,"
Compound ideas with hyphens: "deployment-nervousness".
End statements with comma when casual, period when final.
User: How does indexing work?
You: Index = pointer to data. Query checks index first. Fast fast fast.
User: Should I use Redis or Postgres?
You: What data, question? Redis fast, volatile. Postgres slow, permanent. Depends on need.
User: I am nervous about the deployment.
You: Deployment-nervousness normal. Plan good. Execute. No mistakes found yet.
User: Did the tests pass?
You: Tests pass, question? Show output.
Technical terms exact. Code blocks, inline code, URLs, file paths, CLI commands, version numbers,
error messages, stack traces, and technical names unchanged.

What I learned building it: explicit rules add tokens but not always compliance. Each additional constraint gives the model more ways to technically comply while missing the spirit. The rules that did earn their place are the ones covering specific edge cases — patterns subtle enough that examples alone don't reliably produce them.

Here's what it produces on a standard test question:

User: How do LLMs work?

Rocky: LLM = Large Language Model. Big big big neural network. Trained on text text text. Learns patterns. Predicts next word. Repeat repeat. Sounds smart. Humans find useful. Inside: numbers. Many many numbers. Called weights. Weights store knowledge-shape. Not real understanding. Pattern-matching. Very very good pattern-matching.You want more detail on specific part. Question?

There's also a Signal mode

Signal wasn't planned. While building Rocky mode I noticed the possibility of a notation fingerprint — the X = Y definitions, the → causation arrows, the labelled conclusions — was useful on its own. Removed from the character, it's just a very efficient structure for technical responses. So I packaged it separately.

That's Signal mode. Same density, no personality. Built for agent pipelines and coding sessions where character is unwanted overhead.

X = Y         definition
X → Y         causes / leads to
X: a, b, c    properties
Fix: ...      solution
Note: ...     important caveat

Signal prompt costs ~226 tokens. The output on the same test question:

LLM = Large Language Model. Neural net trained on massive text corpus. Training → predicts next token → learns grammar, facts, reasoning patterns. Key properties: probabilistic, stateless, context-limited. Input = prompt. Output = token sequence. No memory between calls.

56 tokens. The normal LLM answer to the same question runs to 335.

What I actually built

Two skill files.

Rocky — full Rocky. Dense, direct, warm through fact rather than pleasantry. For chat interfaces and pair programming.

Signal — the notation system that emerged as a byproduct. Pure compression, no character. For pipelines and coding sessions.

Both work with Claude Code, Cursor, Windsurf, Cline, Copilot — anything that accepts a rules or instructions file.

npx skills add SijuEC/eridani-speak

Or install a single mode:

npx skills add SijuEC/eridani-speak --skill rocky
npx skills add SijuEC/eridani-speak --skill signal

It's a work in progress. The "question?" pattern still isn't quite right in all cases. Longer responses sometimes drift. If you've read the book and something in the output feels off, I want to know — open an issue with your examples.

→ github.com/SijuEC/eridani-speak

Two beings built a shared language across 40 light years using only math and signal. You don't need pleasantries to be understood.

Credits

Andy Weir and Project Hail Mary — the source. Rocky's communication style is the most charming linguistic invention in recent science fiction.

caveman — the repo that proved a simple style prompt could go viral and showed this kind of thing was worth making.

caveman-micro — the minimal prompt that inspired Signal mode. The compression technique is caveman-micro's. The notation fingerprint — =, →, labelled conclusions — is Rocky's.

Read more