DEV Community: heric libong

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

heric libong — Wed, 04 Mar 2026 10:58:38 +0000

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

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.

Infograph2Data: Unlocking the Data Trapped in Pixels 📊

heric libong — Mon, 16 Feb 2026 07:31:03 +0000

This is a submission for the GitHub Copilot CLI Challenge

Infographics and charts are everywhere… but the numbers inside them are often stuck in images and PDFs. If you work in journalism, reporting, research, or data storytelling, you’ve probably retyped values by hand (slow), or avoided using a chart altogether (worse).

Infograph2Data is a web app that turns static charts (PNG/JPG) and PDF pages into structured data you can actually use: CSV / Excel / JSON.

What I Built

A Visual Data Extraction pipeline with a clean “human-in-the-loop” workflow:

1) Upload an image or a PDF

2) Identify chart type + structure (line/bar/pie/scatter, etc.)

3) Select what to extract (series, axes, categories)

4) Review and edit the extracted numbers in a spreadsheet-like UI

5) Export to CSV / Excel / JSON

This is designed for real-world usage: you don’t blindly trust the model—you validate and correct before exporting.

Why this exists (the genesis)

I’m building tools around data storytelling and journalism workflows. A lot of valuable information is published as visuals (reports, infographics, screenshots, press charts), but using that data in analysis or visuals requires manual work. Infograph2Data was built to bridge that gap: “from pixels to data” in minutes.

Demo

✅ Live demo (Hugging Face Space):

✅ GitHub repository:

https://github.com/hericlibong/Infograph2Data

No login required. Just upload a chart/PDF or screenshot PNG or JPG and run the flow.

Demo assets for judges

The repo includes a demo_assets/ folder with multiple chart styles (bar/line/pie + PDF).

This lets judges test quickly without hunting for files.

https://github.com/hericlibong/Infograph2Data/tree/main/demo_assets

Tech Stack (high-level)

Backend

FastAPI (API + serving the built frontend)
Vision-capable LLM extraction (OpenAI key-driven)
PDF support (page rendering + multi-page flows)
Structured schemas + validation

Frontend

React + Vite (TypeScript)
5-step wizard UI
Spreadsheet-like review/edit experience
Clear API health indicator

Deployment

Docker-ready
Hugging Face Spaces demo

The “Copilot CLI-first” part (this is the core of my submission)

This project was built with GitHub Copilot CLI as my main sidekick in the terminal.

Every major step started as a prompt, not as copy/paste from external code:

architecture & folder structure
FastAPI routers + services
frontend pages/components for the 5-step flow
debugging sessions (logs → hypothesis → patch)
deployment fixes and dev/prod parity adjustments

I kept a full “prompt trail” inside the repository:

/docs/prompts_history.md (the seed prompts + planning)
/docs/devlog.md (the step-by-step build + decisions + fixes)

That means judges can audit the process: it’s prompted development end-to-end, not repackaging code from elsewhere.

Important note: I intentionally avoided pulling in random snippets from the internet. The work here is original and built from scratch, with Copilot CLI assisting me as a terminal-native engineering copilot.

A concrete example where Copilot CLI saved the day (deployment bug)

Right before submission, the Hugging Face demo was “live” but uploads failed:

/api/health returning 404
POST /api/files returning 405

This was a classic frontend/backend routing mismatch:

the frontend called /api/*
the backend exposed routes at /health, /files, etc.
requests fell into the SPA catch-all route → 404/405

Using Copilot CLI in the terminal, I quickly:

diagnosed the mismatch from server logs
updated the backend routing to use a consistent /api prefix
ensured local dev matched production by keeping the /api prefix in the Vite proxy

Result: ✅ demo works again, and local dev stays aligned with prod.

Usability & UX choices (judging criteria)

To make this judge-friendly and actually usable:

5-step guided flow (no guessing)
Health indicator (you instantly know if the API is reachable)
Human-in-the-loop review (edit before export)
Instant export to formats people really use (CSV/Excel/JSON)
Demo assets included (fast testing)

If you want to run it locally (quick)

git clone https://github.com/hericlibong/Infograph2Data.git
cd Infograph2Data
cp .env.example .env   # add your OPENAI_API_KEY
docker build -t infograph2data .
docker run -p 7860:7860 --env-file .env infograph2data

My Experience with GitHub Copilot CLI

Copilot CLI was most valuable when:

turning vague requirements into a clean architecture fast

generating consistent scaffolding across backend + frontend

debugging from real logs under time pressure

keeping momentum without leaving the terminal

This challenge theme is spot-on: Copilot in the terminal isn’t just autocomplete—used well, it becomes a workflow accelerator.

Connect & Repositories

SassyAI: The Sarcastic AI Assistant

heric libong — Sun, 11 May 2025 23:33:48 +0000

This is a submission for the Amazon Q Developer "Quack The Code" Challenge: That's Entertainment!

What I Built

SassyAI: The Judgy Assistant

SassyAI is an interactive, sarcastic AI assistant that never fails to roast users with witty, snarky, and sometimes outright rude responses. Designed for developers and tech enthusiasts looking for a humorous break, SassyAI doesn’t just provide answers—it provides attitude.

Update (V2 is live 🚀)

A new version is available as a web chatbot powered by an LLM, with a fresh UI and a versioned persona.

Repo (V2): https://github.com/hericlibong/SassyAI

Live demo (Hugging Face): https://ricolajazz-sassy-ai.hf.space

Features:

Dynamic Theme Switching: Choose between several sarcasm-infused themes (e.g., general knowledge, coding, philosophy, food debates, rogue AI fears).
Customizable Contexts: Easily add new sarcastic themes by sending prompts to Amazon Q.
One-Session Interactivity: No need to restart the app—switch themes and continue bantering seamlessly.
Personalized Experience: The user can set a nickname to make interactions more engaging.
Visual Flair: Thanks to the integration of Rich, SassyAI’s responses are not only witty but also visually appealing.
Command Guide: Interactive help and theme selection directly from the chat.

SassyAI is not just an AI assistant; it’s an AI that doesn’t care about your trivial questions—and isn’t afraid to say it.

Demo

Code Repository

Repo github

How I Used Amazon Q Developer

Amazon Q Developer played a crucial role in generating sarcastic responses for different contexts. Here’s how we leveraged it:

1. Automated Sarcasm Generation:

We crafted context-specific prompts to elicit humorous and ironic replies.
For instance, for the "general knowledge" theme:

Act as a sarcastic AI assistant who refuses to answer simple factual questions.
Generate 5 different humorous responses for the question: "What is the capital of France?"
The tone should be mocking, but clever.

Amazon Q delivered varied responses, which we integrated seamlessly into the engine.py file.

2. Theme Expansion:

We used Amazon Q to quickly prototype new contexts like "sports" or "nerd culture" by generating sarcastic replies based on custom prompts.
The responses were automatically structured and added to the engine for fluid integration.

3. Customization:

The modular nature of the responses allows for quick addition of new themes.
Users can extend the list by simply sending a prompt in the correct format to Amazon Q.

Installation and Usage

Prerequisites:

Python 3.12

Installation Steps:
1 - Clone the repository:

git clone https://github.com/hericlibong/SassyAI-v1
cd SassyAI

2 - Create and activate the virtual environment:

python3.12 -m venv venv
source venv/bin/activate

3 - Install dependencies:

pip install -r requirements.txt

4 - Run the CLI:

python sassy_ai/main_cli.py 
or cd sassy_ai
python main_cli.py

Log File

SassyAI generates a log file (amazon_q_log.md) that documents each prompt sent to Amazon Q and the corresponding responses. This log provides transparency regarding which contexts were generated automatically and helps in tracking future improvements.

Customization: Adding Your Own Themes

SassyAI is designed to be extensible. You can easily add your own sarcastic themes using Amazon Q.

Example: Adding a "sports" theme

1 - Generate responses with Amazon Q:

Act as a sarcastic AI assistant who dislikes sports discussions.  
Generate 5 different humorous responses for the question on sport events, sport practice, or sport personality.  
The tone should be mocking, as if the AI finds sports debates boring or trivial.

2 - Amazon Q Integration:

The responses will be automatically placed in the engine.py file under custom_responses.
The corresponding regex will be added to custom_patterns.

3 - Update the theme list:
Modify main_cli.py to include the new theme

"sports": {"prompt": "Who is the best football player?", "color": "blue", "emoji": "⚽"},

Feedback and Contribution

Your feedback is welcome!
Feel free to contribute by creating pull requests or submitting issues on GitHub.
Let’s make SassyAI even sassier!