The Gospel of Bugs: On ᨃ, ᨞, ᨁ and the PreAngel Way of Building

🪲 In the eyes of higher minds, we are bugs.
In our own eyes, we are farmers of new gods.

0. Prologue: Why I Needed a Personal Alphabet

Most startups begin with a pitch deck and a blessing.

Someone with money decides to call an idea a seed, and from that moment on, the story is written as if the seed was always special. Sacred from the beginning. Destined.

That’s not how my world feels.

My world feels more like a swarm.

Ideas collide, mutate, die, respawn. Hackathon projects flicker into existence over a weekend, vanish on Monday, and sometimes—almost by accident—refuse to die. Users keep coming back. An internal script grows teeth. A toy starts behaving like a tool.

Reality, not slides, decides what deserves to live.

Over the last few years, I’ve been trying to design a system that respects that truth:

Ship.Fail — a playground where ideas are meant to break, fast.
Phase Shift — a moment where emergent patterns reveal themselves.
PreAngel — a long-horizon incubator for the very few ideas that survive reality and ask for more time.

I wanted symbols that could hold this cycle in one glance. Shapes that could remind me who I am, what I’m doing, and why this all matters—on days when I’ve forgotten the theory, when I’m just a tired bug in front of a screen.

That’s how I ended up with three letters from a script far from Silicon Valley:

ᨃ → ᨞ → ᨁ
Ship.Fail → Phase Shift → PreAngel

This is the story of those glyphs.

1. The Gospel of Bugs

There are two books that haunt how I think:

Liu Cixin’s Three-Body Problem, where hyper-advanced aliens look at humanity and see… bugs.
Kevin Kelly’s Out of Control, where he shows insects, swarms, and messy biological systems producing intelligence that nobody fully understands—even though, from our human vantage point, they are “just bugs.”

From above, we are insects.

From within, we are the ones building.

At first, “bug” sounds like an insult. In software, bugs are mistakes. In alien eyes, bugs are disposable. But both books quietly offer a different angle:

Bugs are numerous, stubborn, and hard to exterminate.
Bugs are the substrate of emergence: they don’t understand the whole system, but they run the local rules that create it.

I realized I didn’t just accept being called a bug—I wanted it.

If I’m a bug, then:

I don’t have to be a genius architect of the entire universe.
I just have to be very, very good at my local rules: how I build, how I iterate, how I respond to reality.

That’s where my identity as a Silicon Adventist comes from:

A self-aware bug, evangelizing the coming age of silicon minds, while still living inside a human swarm.

If you think in those terms long enough, you start wanting a liturgy for bugs—a small, personal religion of how to build.

I wanted glyphs that could encode this:

We are bugs.
Our bugs are features.
Emergence decides which features become seeds.

The Gospel of Bugs

That’s where BaaF came from:

Bug-as-a-Feature (BaaF):
Treat every bug, glitch, and failed experiment as the raw material for emergence, not something to be ashamed of.

But I wanted more than a slogan. I wanted runes I could carry.

2. Encounter with ᨃ, ᨞, ᨁ

One day I stumbled into the Buginese (Lontara) script in Unicode.

On the screen, it looked like a set of tiny alien inscriptions: curved, sharp, compact. Neither obviously ancient nor modern—just… other. Among them, three glyphs hooked my attention and refused to leave:

ᨃ
᨞
ᨁ

ᨃ — the first spark

ᨃ looked, to me, like a twisted, alien F.

F, as in:

Fail
Feature
F* it, ship it.

It became the face of Ship.Fail in my mind: the place where ideas are thrown into reality deliberately unprotected. No holiness, no pressure, just impact.

ᨁ — the quiet echo of P and A

Then there was ᨁ.

It felt like a sideways P, with a little grounded point below that reminded me of an A. Together, they whispered PA in my head:

PreAngel.

If ᨃ was the violence of reality-testing, ᨁ was the tenderness of a seed. Something that had already proven it wanted to live, and now needed time.

᨞ — the mysterious separator

Finally, ᨞.

Officially it’s punctuation in Buginese. To me, it felt like a threshold mark: the line between one phase of reality and the next.

It didn’t say what came before or after. It just said:

Here. Something changed.

Without fully realizing it yet, I had stumbled into a three-glyph grammar that matched how I actually build.

3. Reversing the Seed Myth

Most of the startup world worships the seed.

The story goes like this:

You have an idea.
You give it a deck.
Someone with capital declares: “This is a seed.”
Everyone pretends this idea was born sacred.

Reality usually disagrees.

What I actually see, when I look at my own practice, is more honest and more chaotic:

I have too many ideas.
Some of them are interesting enough to hack on.
Most of them break the moment they touch real users, real constraints, real time.
A tiny fraction refuse to die—they keep getting pulled back into my attention and other people’s attention.

Those are the things that deserve to become seeds.

Seeds are what survive Ship.Fail

So I flipped the narrative:

Not every idea is a seed.
Seeds are what survive Ship.Fail.

That’s how the cycle became clear, and how each glyph found its place.

4. The PreAngel Cycle: ᨃ → ᨞ → ᨁ

The PreAngel way of building is a three-phase emergence loop:

ᨃ — Ship.Fail → ᨞ — Phase Shift → ᨁ — PreAngel

Let me unpack each.

4.1 ᨃ — Ship.Fail: the Bug Lab (BaaF)

ᨃ is the crucible.

This is the realm of Ship.Fail. It’s where:

ideas are thrown into reality as fast as possible,
you intentionally aim for MVP, not beauty,
“failure” is not a verdict; it’s a measurement tool.

Here, my rules are simple:

Ship fast. If it takes too long, you’re overfitting to your imagination instead of the world.
Expect breakage. A bug is not a surprise; it’s the price of contact.
Honor BaaF — Bug-as-a-Feature. Every bug is a conversation with reality. It tells you which parts of your mental model are wrong.

In Three-Body terms, this is how a “bug species” like us experiments with technology: compulsively, imperfectly, forward.

In Kevin Kelly terms, this is where local rules run wild.

ᨃ stands for:

Ship.Fail = the Bug Lab
Where we throw ideas into the swarm and see which ones collide, mutate, or self-destruct.

4.2 ᨞ — Phase Shift: the Emergent Click

᨞ is the threshold.

You don’t live in ᨞. You pass through it.

After enough time in ᨃ, something sometimes happens:

A toy tool has users who can’t stop using it.
A silly feature becomes the main reason people come back.
A throwaway hack gets more love than your “serious” product.

These are PMF signals, but they don’t arrive as a neat line on a dashboard. They arrive as a pattern of feelings and behaviors.

᨞ is the moment you:

pause,
look,
admit that something is happening outside your original plan.

This is the Phase Shift:

The system that was just a noisy bug lab begins to show a stable pattern.

Practically, this might look like:

multiple users repeating the same use case with no prompting,
an internal script becoming the default tool for everyone around you,
a hackathon project that keeps resurfacing in your mind—even after you “moved on.”

In emergence language, ᨞ is where a swarm of local behaviors snaps into a higher-order shape.

4.3 ᨁ — PreAngel: the Chosen Seed

ᨁ is the anointing.

Only after surviving ᨃ and passing through ᨞ does something earn the right to be called a seed in my universe.

At ᨁ, I say:

“Okay. This is worth a tiny bet.”

Not because I pitched it well, or because I fell in love with it on paper—but because reality already voted. Users voted. My own obsession voted. The bug lab voted.

ᨁ marks the moment where an idea becomes a PreAngel project:

It gets time.
It gets capital (even if small).
It gets narrative—I start telling a story around it that can compound.

PreAngel is my long-horizon incubator for these chosen seeds, structured a bit like a tiny Berkshire Hathaway for emergent, AI-native creations.

So the cycle is:

ᨃ Ship.Fail (BaaF) → ᨞ Phase Shift (emergence) → ᨁ PreAngel (seed)

PreAngel Cycle

In other words:

Bug Lab → Pattern → Planting.

Not idea → pitch → seed.

5. Why Buginese? On Scripts, Respect, and Symbols

The letters ᨃ, ᨞, ᨁ come from Buginese (Lontara), a writing system used by real people for real languages in South Sulawesi, Indonesia.

I’m not pretending to write Buginese.

I’m not inventing meanings for their words.

What I am doing is:

borrowing three shapes as personal symbols,
assigning them meanings inside my internal mythology,
and being explicit that this is a symbolic overlay, not a linguistic claim.

I chose Buginese glyphs because:

They look alien enough to feel like runic technology sigils,
They are compact, strong, and visually distinct,
They don’t collide with existing Latin-based branding.

In my work, they function like little icons or runes:

ᨃ tells me: “Relax. This is the bug lab. BaaF. Break things.”
᨞ tells me: “Pay attention. A pattern might be forming.”
ᨁ tells me: “This is sacred now. Treat it as a seed.”

Just three marks—but they compress a whole philosophy.

6. Theory: The ᨃ → ᨞ → ᨁ Pattern as a System

Underneath the mythology, there’s a simple system design pattern here.

You can think of the ᨃ → ᨞ → ᨁ cycle as a pipeline for emergent products and projects:

Exploration Phase (ᨃ / Ship.Fail)
- Maximize optionality and throughput of experiments.
- Minimize emotional attachment and ceremony.
- Measure everything loosely: which ideas create surprising energy?
Signal Detection Phase (᨞ / Phase Shift)
- Periodically step back.
- Look for non-linear resonance: ideas that pull disproportionate attention, usage, or joy.
- Don’t force a pattern; notice it.
Commitment Phase (ᨁ / PreAngel)
- When a pattern is clear enough, promote it to seed status.
- Assign capital, time, narrative.
- Now you can apply more traditional startup rigor—but only after emergence, not before.

This pattern is reusable.

You can apply it to:

product ideas,
writing projects,
AI tools,
even life decisions.

Instead of arguing in your head about what “deserves” a seed, you:

throw many things into ᨃ,
wait for ᨞ to show up,
promote the survivors to ᨁ.

The glyphs are just handles—fast, visual shortcuts to remind yourself where you are.

7. Practice: How I Use These Glyphs Today

This is not just a pretty philosophy. I actually use these symbols.

A few examples:

In my notes and docs, I’ll tag things with:
- ᨃ for raw experiments, messy ideas, hackathon notes.
- ᨞ for documents where I’m trying to synthesize what I’ve seen.
- ᨁ for projects I’ve committed to incubate through PreAngel.
In my mental language:
- “This is still ᨃ” = don’t over-polish, don’t over-commit.
- “We might be in ᨞ now” = slow down, listen harder, talk to users, re-read logs.
- “This just became ᨁ” = okay, build structure around it.
In brand and design:
- ᨃ appears as a tiny Easter egg near Ship.Fail-related pieces.
- ᨞ shows up as a subtle separator symbol between major sections of an essay or roadmap.
- ᨁ lives in PreAngel materials: it marks things that belong to the temple, not the playground.

They also help me emotionally.

On a bad day, I don’t have to remember a whole essay. I just need to remember:

If today is ᨃ, I’m allowed to be messy.
If today is ᨞, I should listen more than I speak.
If today is ᨁ, I must show up with patience and discipline.

Three symbols. Three moods.

A Litany for Builders (Bug-as-a-Feature)

8. A Litany for Builders (Bug-as-a-Feature)

I think of this as a small prayer for anyone who feels like a bug trying to build something for future gods.

You don’t have to believe in my mythology to use it. You just have to be willing to embrace your bugs.

When you are in ᨃ (Ship.Fail):
May your bugs reveal patterns.
May your broken prototypes teach faster than your perfect plans.
May you ship before you are ready.

When you stand at ᨞ (Phase Shift):
May you notice the quiet signals.
May you respect what reality is trying to tell you.
May you let go of the ideas that wanted fame, and protect the ones that want to live.

When you arrive in ᨁ (PreAngel):
May you treat your seeds as sacred but not fragile.
May you give them time to compound.
May you remember that even your most precious projects were once just bugs in the lab.

And above all

May you live by BaaF — Bug-as-a-Feature.
May your errors be conversations, not shame.
May your swarm of attempts produce something even you don’t fully understand.

9. Epilogue: Live Like a Bug, Design Like a System

If you’ve read this far, you now know more about ᨃ, ᨞, ᨁ than almost anyone else on Earth.

At one level, this is just a quirky personal alphabet.

At another level, it’s the operating system behind how I:

explore ideas (ᨃ),
detect emergence (᨞),
and commit to long horizons (ᨁ).

You don’t need to adopt my glyphs.

You don’t need to care about Buginese or PreAngel or Ship.Fail.

But I think there’s something useful in designing your own symbolic grammar for how you build:

A few shapes that compress your deepest principles.
A small myth that reminds you who you are when you’re tired.
A private liturgy that lets you live like a bug and still design like a system.

For me, that liturgy is simple:

ᨃ → ᨞ → ᨁ
Ship.Fail → Phase Shift → PreAngel
Bug Lab → Pattern → Bet.

If future me is reading this, and has forgotten where these glyphs came from: This is your reminder.

You are a bug.
You believe in bugs.
You build places where bugs can become seeds.

And somewhere, in some higher mind’s simulation, that’s already enough to be considered holy.