Ashfeather is a poetic short story.I want to start by discussing the impulsive inspiration which resulted in its conception - especially in relation to the cover art. You’ll notice behind the bird is a collection of symbols/glyphs. These weren’t randomly chosen. There’s meaning embedded in them.
Over the past week or so, I’ve been researching and playing with LLM context windows. As a result, I’ve been experimenting with methods to compress data for input with less token cost, and ideally with no information loss. It’s a wierd concept for sure. Considering there are software engineers with degrees in linquistics - I don’t expect to build anything that doesn’t already exist but - the learning process is worthwhile. And that’s not to say it’s been all for nothing:
I’ve been building an encoder and decoder system—something that takes regular human language, filters out words or constructs that carry minimal contextual weight, and compresses what remains into a denser, more efficient format.
The core idea? Take a full paragraph of human-readable text, compress it without losing its underlying intent, and use that compressed version to prompt a large language model (LLM).
If you’re not already familiar with how LLMs work, here’s a brief overview:
For example, if you’re working on a codebase with 10,000+ lines and trying to get help with it, the model might initially do well—but over time, it’ll start forgetting prior inputs. This leads to hallucinations—fabricated or incorrect output that sounds plausible. Because LLMs are trained to always respond, they won’t admit confusion—they’ll just fill in the blanks, even if wrong.
Every message you send and every reply the model gives is counted in tokens. If your model supports 10,000 tokens and you write 2,000 and it responds with 3,000, you’re already halfway through the memory stack.
English is verbose. Many words—articles, connectives, fluff—don’t carry much meaning. A model can still interpret the message correctly even if a lot of these are removed. That’s one vector for compression.
But here’s where it gets deeper…
Enter Unicode. It includes character sets from languages like Chinese, Japanese, Russian, Greek, etc. Some of these characters represent complex concepts in just a single symbol.
So if you take a sentence like:
“The boy wants to know if he has more pennies in his jar than his friend.”
You can:
> symbol.This transforms verbose natural language into a kind of symbolic shorthand. To humans, it’s borderline unreadable. But to the LLM, it’s still interpretable—especially if we define a key or context schema.
I’ve been experimenting with building a unified compression method—a “Promptese,” if you will. The idea is that a paragraph goes in, and a compressed symbolic stream comes out. You might not be able to read it, but the LLM can.
If you compress a 1,000-token input down to 400–500 tokens, you’re drastically increasing how much information can fit into context. That’s huge for agents, pipelines, or advanced workflows where every token matters.
Sure—you can fine-tune a small LLM on this system, train it on your own compressed language, and have it decode that format. But unless you’re deploying the model at scale, it’s not that useful. Most people are using hosted models (OpenAI, Anthropic, etc.), so they can’t retrain the base model.
That’s why this approach focuses on external compression. It works with existing models. It’s a symbolic wrapper. Think of it as zipping your thoughts before you send them.
Lets jump into it. I created an encoder, and alongside it, a decoder. The encoding part worked great. The decoding… not so much. But honestly, that’s not a deal-breaker. I should stress this—bidirectional encoding and decoding aren’t always necessary. In my vision, the encoding is the essential piece. Once compressed, the LLM should still be able to interpret it and generate a meaningful response.
If the model replies in English, yes, the return will be token-heavy—but that’s okay. You don’t need to decrypt it like a secret message. This isn’t encryption. It’s compression. It’s okay to take baby steps.
What I built uses symbolic character sets to condense meaning. But before I ramble: the key tools I’ve been leaning on are TLKM and spaCy—two Python libraries that handle natural language processing. They help identify the grammatical structure of a sentence. They tag parts of speech, highlight relationships, and map out the skeleton of meaning.
So, for example, the system might determine: this is a verb, and based on its placement, that must be an adverb. This matches a known pattern. From there, it can extract the linguistic architecture and then rewrite it symbolically.
But here’s the catch: context is lost. Symbolic compression strips out names, specifics, emotional tone—anything not structurally necessary. You’re left with the framework. A skeleton.
Think of it like this: imagine compressing the Bible through this system. You’d get a reduced, unreadable glyph-stream—completely symbolic. The story wouldn’t be recognizable, but the structure might remain. You’d still see themes like belief, sacrifice, divine conflict. It becomes a shadow of itself—a logical framework more than a narrative.
Now extend that thought to religion as a whole. Despite differences in doctrine and storytelling, most spiritual systems echo the same core ideas: higher powers, morality, consequence, transcendence. The specifics shift, but the structure is surprisingly consistent.
And that’s where this idea finds footing. Even if details are lost, the structure remains useful. It becomes a way to examine shared human patterns without the baggage of form.
So what I did was grab a random public-domain book—18 chapters in total—and parsed it chapter by chapter. I encoded each one using my system and redirected all output into a single file. At that point, the original context was gone. Then I decoded it. Not to reconstruct the book perfectly, but to generate a summary—to see what remained.
What emerged was skeletal but strangely compelling. A distilled ghost of the original, yet with clarity in its structure. I took that as the foundation for a new short story.
I gave the LLM specific constraints: reduce the length from 18 chapters to 6. I didn’t want something sprawling like my book ZILD —that’s a massive effort. I wanted it tighter. Focused. I also set symbolic anchors—the number 6 is significant. Six chapters. Six feathers. Six returns. That motif threads through the narrative like a heartbeat.
I gave it the skeleton, the rules, and let it breathe life into the story.
And I’m proud of what came out. The story it generated was built from loss—of detail, of names, of recognizable plot—but it still feels complete. The symbols you see on the cover? They’re not decorative. They’re the literal encoding of the story’s core structure. The narrative reflects the process that created it.
That’s the point.