Cibelmoon: Lunar Reflection Companion

A native Android companion blending lunar context, personal journaling, symbolic rituals and tarot, built through human-directed AI collaboration and hardened for real-world use with Codex.

Comment

Inspiration

Cibelmoon began with a simple question: what would a lunar app feel like if it were not only a calendar, but a quiet personal space?

Many moon apps show phases, signs, or isolated facts. I wanted to create something more cohesive: an experience where lunar context could lead naturally into reflection, journaling, symbolic rituals, and tarot without presenting any of them as fixed predictions or medical advice.

The project was also inspired by a second challenge: discovering how far a solo creator could take a native mobile product through human-directed collaboration with AI. Cibelmoon was developed iteratively with ChatGPT, then audited and production-hardened with Codex during OpenAI Build Week.

What it does

Cibelmoon is a native Android lunar reflection companion.

The app combines:

  • a lunar observatory with current moon context;
  • a private personal journal;
  • “elevated” phrases that users can choose to share symbolically with the moon;
  • safe symbolic rituals;
  • AI-assisted lunar energy experiences;
  • a tarot reading system built around a seven-card Split Hexagram spread;
  • a persistent virtual currency called Cibelias;
  • daily rewards, streaks, and rewarded-ad flows;
  • authenticated, anonymous, and guest-aware user experiences.

The goal is not to tell users what will happen. Cibelmoon is designed to support reflection, intention, and personal interpretation while preserving user choice.

The app uses server-side validation for paid AI experiences, persistent wallet state, Firestore-backed journal entries, and protected Cloud Functions for sensitive operations.

How we built it

Cibelmoon is built as a native Android application using:

  • Kotlin;
  • Jetpack Compose;
  • Hilt;
  • Firebase Authentication;
  • Cloud Firestore;
  • Firebase Cloud Functions;
  • Firebase App Check;
  • Crashlytics;
  • DataStore;
  • AdMob and UMP;
  • Google Gemini for selected runtime AI features.

The development process was highly iterative. I defined the product rules, visual identity, safety boundaries, pricing, and user experience, while AI tools helped me explore architecture, write and refactor code, inspect logs, diagnose failures, and validate flows.

During OpenAI Build Week, I used Codex as a repository-level engineering collaborator rather than only as a code generator.

Codex was asked to:

  • inspect existing Android and Firebase architecture;
  • identify production risks;
  • trace failures across Android, Cloud Functions, and Firestore;
  • review persistence and authorization;
  • improve error recovery;
  • preserve cost controls;
  • validate builds and critical flows;
  • document changes and remaining risks.

One Build Week example involved the elevated lunar phrase judge. The initial implementation used Gemini Flex inference to reduce cost, but Flex repeatedly returned temporary 503 UNAVAILABLE errors.

The original behavior had three problems:

  1. failed provider calls could consume the user’s daily review attempts;
  2. the app exposed technical errors such as DEADLINE_EXCEEDED;
  3. the phrase was never saved because the workflow stopped before journal persistence.

The revised backend now:

  • tries Flex first;
  • retries temporary provider failures;
  • falls back to Standard only for this inexpensive, short-form judge;
  • refunds the review attempt when all providers fail;
  • records which service tier completed the request;
  • preserves metrics such as latency and token usage;
  • returns user-friendly messages instead of infrastructure terminology.

This fallback was deliberately not added to tarot because tarot generation is much larger and more expensive. In that flow, users keep their Cibelias and can retry later. That distinction reflects a human product and cost decision, not an automatic model choice.

Challenges we ran into

The hardest challenge was coordinating multiple stateful systems at once.

A single user action can involve:

  • Android UI state;
  • Firebase Authentication;
  • App Check;
  • Firestore security rules;
  • Cloud Functions;
  • AI provider availability;
  • wallet balances;
  • daily limits;
  • journal persistence;
  • public phrase visibility.

A failure in one layer could look like a completely different problem in another.

For example, a phrase that appeared not to save initially looked like a Firestore rules issue. Logs later showed that authentication and App Check were valid, while the actual failure was temporary AI model saturation occurring before the journal entry was created.

Another challenge was balancing reliability and cost. Always using the most reliable service tier would improve availability, but it would also make expensive features harder to sustain. The final design uses different recovery strategies depending on the size and cost of each feature.

We also had to protect against:

  • duplicate rewards;
  • repeated wallet operations;
  • anonymous-account abuse;
  • stale authentication listeners;
  • process restarts;
  • partially completed purchases;
  • unclear error messages;
  • Compose recomposition triggering unintended behavior.

Accomplishments that we're proud of

I am especially proud that Cibelmoon is not only a visual prototype.

It includes real production infrastructure:

  • working Google, email, anonymous, and guest authentication;
  • persistent user data;
  • Firestore security rules;
  • Cloud Functions with server-authoritative operations;
  • a persistent Cibelias wallet;
  • daily rewards and streak state;
  • protected AI flows;
  • App Check integration;
  • privacy and account deletion flows;
  • internal Google Play distribution;
  • AdMob consent and rewarded-ad architecture;
  • crash reporting and production diagnostics.

The elevated phrase workflow now successfully completes the full chain:

  1. the phrase is reviewed;
  2. the private journal entry is created;
  3. the accepted phrase is published;
  4. the journal entry is marked as elevated;
  5. the review is marked as used;
  6. the final state is restored from Firestore.

In one validated test, both Flex attempts failed, Standard completed the review, and the backend recorded:

  • fallbackUsed: true;
  • flexAttempts: 2;
  • serviceTier: standard;
  • status: ACCEPTED.

The user still experienced one continuous action instead of seeing the infrastructure struggle underneath it.

What we learned

The biggest lesson was that AI-assisted development works best when the human provides clear boundaries.

Codex was most effective when given:

  • a precise goal;
  • product constraints;
  • known invariants;
  • build and test commands;
  • explicit rules about what must not change;
  • evidence from logs and Firestore;
  • a requirement to explain impact and validation.

Broad prompts such as “review everything” are less useful than asking for a prioritized audit followed by focused implementation goals.

I also learned that generating code is only one part of building a real product. Reliability often depends more on understanding failure order, idempotency, authorization, retries, observability, and user communication.

Another important lesson was that users should never see the language of the infrastructure. Terms such as JSON, HTTP 503, Flex, Standard, or DEADLINE_EXCEEDED belong in logs and metrics, not in the interface.

What's next for Cibelmoon: Lunar Reflection Companion

The next milestone is production readiness.

The immediate priorities are:

  • complete server-side rewarded-ad verification for real Cibelia rewards;
  • finish end-to-end streak reward validation;
  • add more automated tests for duplicate and concurrent wallet operations;
  • continue replacing technical failures with clear recovery messages;
  • expand localization after the critical flows are stable;
  • complete final Google Play production checks;
  • improve observability for AI cost, fallback frequency, and failure recovery.

Future versions may also include richer ritual history, journal connections, completion tracking, improved accessibility, and more refined sound design.

The long-term goal is to keep Cibelmoon personal, coherent, and trustworthy while demonstrating what a solo creator can build when human product judgment and AI engineering collaboration are treated as complementary strengths.

Built With

Share this project:

Updates