DEV Community: Chaminade Dondah ADJOLOU

I vibe-coded a cassette deck for family memory — K7 Mémoire (Sanity Challenge Path 2)

Chaminade Dondah ADJOLOU — Fri, 02 Oct 2026 15:36:05 +0000

I vibe-coded a cassette deck for family memory — K7 Mémoire (Sanity Challenge Path 2)

Author: Chaminade (Dondah Chamiande Adjolou) · Lomé, Togo

Challenge: Sanity Challenge Path 2 — Vibe-code something strange (Sep 18–Oct 4, 2026 PDT)

Tag: #sanitychallenge

Live deck: https://k7-memoire.vercel.app

Embedded Studio: https://k7-memoire.vercel.app/studio

Sanity project ID: nh4vx26w · Dataset: production

Why something strange

In Lomé, family history often travels by voice before it travels by page. I did not want another blog layout for that. Path 2 of the Sanity Challenge asks for something strange — so I vibe-coded K7 Mémoire: a Next.js cassette / radio UI that treats Sanity documents as tapes you can tune, filter by mood, and “play.”

The copy is French, Lomé-flavored. The chrome is a deck: FM dial, mood filters, spinning reels, counter, VU meters, rolling transcript, and a kente stripe. No article list. No card grid. Stories are bandes; narrators are voix.

This sits next to earlier work I care about — like a family-tree project for Hacktoberfest — but K7 Mémoire is its own object: oral memory as an instrument, not a CMS demo with a pretty skin.

The product prompt (and why process matters)

Judges for this challenge weigh process as much as the result. I kept a journal in the repo: PROMPT_LOG.md. The brief I gave the agent was essentially one product prompt:

An oral archive for Lomé, stored in Sanity, played by a cassette-deck UI, with Studio, seed stories, README, and this log.

From there, the log records what landed and what broke. Scaffolding with create-next-app (Next.js App Router, TypeScript, Tailwind) into a subdirectory, then moving to the repo root, was more reliable than aiming the CLI at the root. Studio landed at /studio with next-sanity, Sanity v6, Vision, and a custom desk (Bandes / Voix). One GROQ string is shared by the live client and by groq-js over the seed documents — tests assert eight tapes and resolved narrator names.

Failures were part of the craft: no Sanity credentials in the first environment (so the deck shipped a labeled demo mode using the same query, not a second content model); Vitest peer friction (switched to tsx --test); a Turbopack production build that choked on swr’s react-server export until swr was aliased in next.config.ts; Studio pulled into the RSC graph until the config lived behind a client boundary.

Left undone on purpose in that early pass: no audio files on demo tapes (audioUrl optional — Play falls back to the transcript), and no Cursor branding in the public brief.

That honesty is the submission as much as the UI.

Two schemas: tape and voice

Content is not files on the host. Stories stay in Sanity. The model is small on purpose:

Document	Studio title	Role
`story`	Bande	A tape: title, slug, narrator ref, place, era, transcript (portable text), optional `audioUrl`, tags, mood
`narrator`	Narrateur	A voice: name, short bio (≤280), optional photo with hotspot

The narrator’s name lives on the narrator document. The story only holds a reference. That keeps voices reusable across bandes and keeps the deck’s display join honest: narrator->name in GROQ, not a duplicated string on every tape.

Mood is a required string from a shared list (the filters on the dial). Era is approximate text (e.g. « vers 1987 ») and is what we sort on. Transcript is required portable text so the machine always has something to roll when there is no audio file.

One GROQ string, two sources

Whether the deck reads the Content Lake or the local seed drawer, the projection is the same:

*[_type == "story"] | order(era asc) {
  _id,
  title,
  "slug": slug.current,
  place,
  era,
  mood,
  tags,
  audioUrl,
  transcript,
  "narratorName": narrator->name,
  "narratorBio": narrator->bio,
  "narratorPhoto": narrator->photo.asset->url
}

That single string is the contract between Studio editors and the strange front end. An empty lake shows an open tray, not a crash. A failed query shows the error and no tapes. Demo mode is labeled — same query shape, seed documents in src/sanity/seed/documents.ts.

Studio at `/studio`, then the Lake

Studio is embedded in the Next app at /studio (Bandes / Voix desk + Vision). The path from vibe-coded demo to a real Content Lake was deliberate:

Create project + public production dataset in Sanity Manage.
Set NEXT_PUBLIC_SANITY_PROJECT_ID / NEXT_PUBLIC_SANITY_DATASET (defaults already point at nh4vx26w / production).
Editor write token only for seed — never committed.
npm run seed → createOrReplace 4 narrators and 8 stories.
Add CORS origins (local + https://k7-memoire.vercel.app), deploy, open Studio.

Public project ID and dataset are intentional: the deck can read without a token (watch Sanity’s public ACL: path("*") only matches IDs without dots — our seed uses hyphen IDs like story-radio-agoe). Write stays server-side for seed only.

What “strange” looks like on screen

(Screenshots: seeded deck on live — open the app for the full FM dial + kente chrome.)

You do not scroll a feed. You tune. Mood filters narrow the drawer. Play spins the reels and advances a counter while the transcript rolls — or audio plays when audioUrl is set. The on-screen service manual even prints the GROQ, so the “machine” explains how it listens to the Lake.

Stack in short: Next.js (App Router) + TypeScript + Tailwind + Sanity Studio (next-sanity, Sanity v6) on Vercel.

Links for judges and readers

What	Where
Live app	k7-memoire.vercel.app
Studio	k7-memoire.vercel.app/studio
Sanity project ID	`nh4vx26w`
Dataset	`production`
Seeded content	4 narrators · 8 stories
Origin source of truth	cursor.com/codebase/donchaminade/k7-memoire (private)
Process log	`PROMPT_LOG.md` in that repo
GitHub	Donchaminade
LinkedIn	chaminadeadjolou

What I’d vibe next

Real family recordings behind optional audioUrl (consent and quiet UX first).
More Lomé places and eras as the Lake grows — still one GROQ contract.
A small “donate a tape” flow that creates a draft story in Studio without breaking the deck metaphor.
Vision-assisted queries from the service manual for editors learning GROQ beside the reels.

Strange does not mean unserious. A cassette deck is a joke until it is how your aunt’s voice finds the next generation. Sanity’s schemas, Studio, and Content Lake made that joke into something I can seed, ship, and keep editing from Lomé.

Thanks to the Sanity Challenge for Path 2 — and to everyone who still presses Play on memory.

#sanitychallenge · nextjs · sanity · africa

Lignée — A Family Tree Built for Someone I Love (and Generations I'll Never Meet)

Chaminade Dondah ADJOLOU — Fri, 02 Oct 2026 09:27:11 +0000

Lignée — A Family Tree Built for Someone I Love (and Generations I'll Never Meet)

I did not build this for a portfolio. I built it for my family.

For the Adjolou and Chamiande lineage — for the people who raised me in Lomé, Togo, and for the children who will one day ask who came before us? This is my Hacktoberfest Weekend Challenge submission under Build for a Friend. The "friend" is not a stranger on the internet. It is someone I love: my family, including future generations I may never meet.

Lignée (French for lineage) is an open-source family tree that turns oral family stories into durable digital memory — with open-source AI at the core, a mind-map you can edit on your phone, and a promise that our kinship will not vanish when the last elder who remembers stops speaking.

Who it's for

Someone I love is not a single person. In West African extended kinship, "family" is wider than a nuclear unit: grandparents, aunts, uncles, cousins, marriages that braid two names together, in-laws who become our people.

I am Dondah Chamiande Adjolou, from Lomé, Togo. Like many families in the diaspora — and many still at home — we carry our history in conversations: around a table, on a phone call, in a funeral speech, in a name whispered to a newborn. That memory is rich. It is also fragile.

Lignée is for:

Elders whose stories deserve more than a fading recollection
Parents who want their children to know the tree they grew from
Cousins scattered across cities and continents who still share one lineage
Future generations who will open a phone and see faces and names instead of silence

This is not a generic genealogy product. It is a gift I intend to hand over — to my family first, and then to anyone who needs the same thing for theirs.

The problem: oral memory is fading

In many African families, lineage is oral. That is beautiful — and it is at risk.

Elders pass away, and with them go the precise links: who married whom, which child belonged to which house, how two surnames became one story.
The diaspora stretches kinship across borders. A cousin in Europe and a cousin in Lomé may share blood and still not share a shared map of the family.
Young people grow up knowing that they come from somewhere, without knowing how the branches connect.
Paper notebooks get lost. WhatsApp threads scroll away. A Facebook album is not a tree.

If we do nothing, the next generation inherits love without structure — affection without ancestry they can navigate. I did not want my family's story to depend on whoever happens to remember next Sunday.

I wanted something durable, editable, installable on a phone, and honest about privacy — because family data is not the kind of data you casually hand to a closed cloud.

What Lignée does

Lignée is a web app (and a PWA you can install on your phone) that lets a family build and explore its tree as a living mind-map.

A mind-map of kinship, not a stiff chart

Using React Flow, the tree is a visual graph you can pan, zoom, and rearrange. People are nodes. Marriages, parent–child links, cousins, and in-laws are edges. It feels like thinking on a whiteboard — not like filling a bureaucratic form.

Click-to-edit, rich people cards

Tap a person. Open their card. Add or correct a name, dates, notes, relationships. No ceremony — if Auntie remembers a detail at dinner, you fix it in thirty seconds.

Relationships that match how we actually live

Nuclear-only trees fail African (and many diaspora) families. Lignée models:

Marriages and unions that connect two branches
Cousins and extended kinship, not only parents and children
In-laws — the people who become family by bond, not only by blood

Install it on your phone (PWA)

Family conversations happen on phones. Lignée is a Progressive Web App: install it to the home screen, open it like a native app, and keep the tree close when someone starts telling a story.

Story import — from récit familial to nodes

This is the heart of the project. You paste (or type) a family story — a récit familial — and open-source AI helps turn narrative into structured people and relationships. Then you review, correct, and own the result.

Home view, shown before opening the tree:

Demo walkthrough (screenshots above):

Open the tree — see the Adjolou/Chamiande mind-map.
Tap a person — edit their card.
Paste a short family story — run story import.
Review suggested nodes and links — accept what is right, fix what is not.
Install the PWA on your phone — take the tree with you.

Live demo: https://story-lineage.vercel.app

Source (primary public link): https://github.com/Donchaminade/story-lineage
Origin mirror (optional): https://cursor.com/codebase/donchaminade/story-lineage

Demo note: The Vercel serverless deployment uses ephemeral storage, so demo seed data may reload on cold instances; edits made on a prior instance may not persist.

Open-source AI at the core

I refuse to build a family memory tool that only works if a closed vendor stays friendly, cheap, and online.

How story import works

You provide a natural-language family story (French or English — the language of the telling).
An open AI pipeline (designed for Ollama and local inference, with a local fallback) extracts candidate people, generations, and relationships.
The app proposes nodes and edges on the tree.
A human always reviews. AI suggests; the family decides.

No magic black box that silently rewrites your lineage. Suggestion, then consent.

Why open matters for family data

Concern	Why open-source AI helps
Privacy	Family names, dates, and stories are intimate. Local inference (e.g. Ollama) keeps data on machines you control.
No vendor lock-in	Models and providers can be swapped. Your tree is not hostage to one API's pricing or terms.
Local option	When the network is weak — or trust is low — local fallback still lets story import run.
Inspectability	Open models and open code mean the community can audit how narrative becomes structure.

Closed AI might be convenient. For family lineage, convenience is not enough. Sovereignty over memory is the feature.

How I built it (honest technical notes)

Stack

Next.js — app framework, routing, and a clean path to a PWA
SQLite — simple, portable persistence; easy to back up; no heavy ops tax for a family project
React Flow — interactive mind-map UX (pan, zoom, nodes, edges)
PWA — installable on Android/iOS home screens for real family use
Open AI / Ollama + local fallback — story import without requiring a single proprietary cloud

What went well

React Flow made "kinship as a graph" feel natural quickly — marriages and cousins are just edges with meaning.
SQLite kept the data model honest and movable: a family's tree should be something you can copy, backup, and keep.
Designing for phone-first editing forced clarity: click-to-edit beats multi-step wizards when an elder is mid-story.

What was hard (and still is)

Modeling extended kinship without drowning the UI — African families are dense graphs; the UX has to stay readable.
Story import is only as good as the review loop. Hallucinated cousins are worse than missing ones — so the product bias is: suggest carefully, confirm always.
Bilingual reality (French oral culture, English for this challenge write-up and global open source) — the product must respect the language of the récit, not only the language of the README.

What I would improve next

Richer media on person cards (photos, voice notes of elders telling the story)
Stronger conflict resolution when two relatives disagree on a link
Export/import formats for long-term archival beyond one app

This was a weekend challenge build with a long-horizon intention. The code is a starting lineage of its own: it will grow.

Handing it over — what it means for future generations

When I imagine a child in twenty years opening Lignée, I do not imagine a product demo. I imagine them tapping a great-grandparent's card and reading a note that someone bothered to write down — a marriage that joined Chamiande and Adjolou, a cousin who left and came back, a name that explains their own.

Oral memory gave us warmth. Digital lineage can give us continuity.

I am handing this to my family as a living gift: editable, installable, private by design, open in its AI so we are not tenants on someone else's memory server. If other families fork it for their own surnames and stories, that is the point of open source — lineage that multiplies without being owned.

For Hacktoberfest, this is my weekend challenge. For my family, this is unfinished on purpose: trees grow.

Prize Categories

Overall only.

(This submission does not claim partner tool categories such as Copilot, Cloudflare, Docker, etc., unless those tools were genuinely central to the build. The core stack here is Next.js, SQLite, React Flow, PWA, and open-source AI / Ollama with local fallback.)

DEV Community: Chaminade Dondah ADJOLOU

I vibe-coded a cassette deck for family memory — K7 Mémoire (Sanity Challenge Path 2)

I vibe-coded a cassette deck for family memory — K7 Mémoire (Sanity Challenge Path 2)

Why something strange

The product prompt (and why process matters)

Two schemas: tape and voice

One GROQ string, two sources

Studio at /studio, then the Lake

What “strange” looks like on screen

Links for judges and readers

What I’d vibe next

Lignée — A Family Tree Built for Someone I Love (and Generations I'll Never Meet)

Lignée — A Family Tree Built for Someone I Love (and Generations I'll Never Meet)

Who it's for

The problem: oral memory is fading

What Lignée does

A mind-map of kinship, not a stiff chart

Click-to-edit, rich people cards

Relationships that match how we actually live

Install it on your phone (PWA)

Story import — from récit familial to nodes

Open-source AI at the core

How story import works

Why open matters for family data

How I built it (honest technical notes)

Handing it over — what it means for future generations

Prize Categories

Links

Challenge tags (for DEV.to)

Studio at `/studio`, then the Lake