Unlocking an African Mythology Archive with Gemini: From a Django API to a Living Archive

This is a submission for the Built with Google Gemini: Writing Challenge

What I Built with Google Gemini

What I Built with Google Gemini

I built African Mythology: Living Archive, an application designed to structure and bring to life the mythological pantheons of Sub-Saharan Africa. Using AI, the project organizes mythological entities, their complex relationships, and their visual representations.

The problem: Oral traditions facing a structural challenge

Unlike Greek, Egyptian, or Norse mythologies, the myths of Sub-Saharan Africa are primarily transmitted through oral tradition. Although some information exists online, it is often fragmented, scattered, and poorly structured.

In 2024, I attempted to create a Django API to organize this cultural heritage. The project remained at the “empty shell” stage: for a solo developer, the research effort and manual data entry required to transform oral narratives into structured data was simply too large.

The role of Gemini: Turning the idea into something real

The Google DeepMind – Vibe Code with Gemini 3 Pro hackathon on Kaggle helped revive the project. The central question — “What can we do today with AI that was impossible before?” — became the turning point.

The API architecture already existed, but I lacked a way to quickly explore relationships between entities and generate a coherent visual universe. Gemini allowed me to:

• Explore and test pantheon structures at scale
• Accelerate the structuring of entities and genealogies
• Generate the foundations of an iconography that respects cultural markers

Phase 1 — Hackathon (Experimentation and Vibe Coding)

The starting point was my original models.py file from 2024. Instead of manually writing import scripts, I used this model as context for Gemini to explain the domain logic of the project.

Excerpt from the initial data model:

# Divinities, Heroes and Creatures: base structure
class Divinity(models.Model):
    name = models.CharField(max_length=100)
    ethnicity = ArrayField(models.CharField(max_length=100))
    domain = ArrayField(models.CharField(max_length=100))
    story_description = models.TextField()
 [...]


class Hero(models.Model):
    name = models.CharField(max_length=100)
    story = models.TextField()
    country = models.CharField(max_length=100)
 [...]

class MythicalCreature(models.Model):
    name = models.CharField(max_length=100)
    description = models.TextField()
    habitat = models.CharField(max_length=255)
 [...]

From this base, Gemini helped formalize a consistent JSON structure. This workflow enabled the creation of the first functional prototype using the Build tool in Google AI Studio, following a Vibe Coding approach. At this stage, navigation and structure were validated without requiring a full backend.

Phase 2 — Development and Integration (Antigravity)

After the hackathon, the project moved from prototype to a working engine. This development phase outside the competition made it possible to industrialize the workflow:

• Antigravity: Used to orchestrate the flows between Gemini model calls and the generation of structured content for the application (entities, relationships, and visual prompts).
• Gemini 3 Pro Agent: Used to design orchestration logic and progressively integrate it with the existing API.
• Visualization: Generation of precise prompts for _Imagen (Vertex AI) _to avoid generic representations.

Demo

The current demo represents the first functional stage of a larger roadmap. The long-term goal is to build a true interactive archive of Sub-Saharan African mythologies, enabling users to explore pantheons, their relationships, and their stories through a visual and conversational interface.

You can explore the demo here:

Hugging Face Application (Live):

GitHub Repository (V2):
https://github.com/hericlibong/african_mythology_V2

What I Learned

Working on this project changed the way I think about using AI in a development workflow.

• ** Giving the model** real structure makes a huge difference. Once Gemini had access to my Django models.py, the responses became much more coherent because it could understand the logic of the project.
• LLMs are surprisingly good at structuring narrative data. Gemini helped turn mythological stories into consistent JSON structures that the application could actually use.
• Cultural content requires very precise prompting. Without strong constraints, image generation quickly drifts toward generic representations rather than culturally meaningful ones.

Google Gemini Feedback

Working with Gemini was a key part of turning this project from an idea into a working prototype.

What worked well

• Gemini was very effective at structuring narrative information into usable data. It helped transform mythological descriptions into consistent JSON structures that could be integrated into the application.
• Providing project context (like my Django models) significantly improved the quality of the responses.
• Google AI Studio made it easy to iterate quickly during the experimentation phase.

Where I ran into friction

• Image generation required many iterations to avoid generic or culturally inaccurate outputs, especially for mythological figures tied to specific traditions.
• Moving from experimentation in AI Studio to a more production-ready workflow still requires some learning and tooling adjustments.