The Origin
LVX Tarot began as a focused question: could an AI-generated tarot reading feel specific, considered, and grounded in the symbolism of the cards rather than sounding like a generic chatbot?
I have always been interested in tarot as a visual and narrative system. When I began working with AI APIs, it provided an unusually demanding test for generated language because tone and interpretation mattered as much as factual output.
The first version was deliberately small. A user selected cards, entered a question, and received a reading. The application was one page and one flow; the real experiment was shaping the model’s response into something people wanted to read.
Friends shared it, strangers began using it, and the response was strong enough to justify turning the experiment into a complete product.
The Product Challenge
Nobody needs a tarot reading. People choose one because they want reflection, atmosphere, or entertainment. That means the experience has to earn attention in a way that a required business tool does not.
The mechanics behind the product—model latency, authentication, quotas, subscriptions, and database state—could not be allowed to dominate the interaction. The software needed to get out of the way while still behaving like a reliable application.
At the same time, each generated reading needed to feel personal without pretending the system possessed knowledge it did not. The product depended on careful language design, pacing, and clear interaction rather than novelty alone.
Designing the AI Experience
The AI layer produces interpretations, but the difficult work was defining how those interpretations should sound and how they should respond to a particular question and card combination.
I iterated on prompts, response structure, tone, and context until the output felt closer to a thoughtful reading than a customer-service exchange. Infrastructure could make the request succeed; product work made the answer worth receiving.
The interface controls the rhythm around that generation. Card selection, transitions, waiting states, and the reveal of the interpretation are paced as one sequence so the user experiences a reading rather than a form submission followed by API text.
Building a Distinct Visual World
I designed LVX Tarot with a dark custom GLSL canvas filled with animated shooting stars. The environment establishes the mood before a user selects a card or reads a line of copy.
The shader is not a decorative block inserted below the interface. It acts as the product’s atmosphere, allowing the conventional account and subscription mechanics to exist inside an experience that still feels mysterious and intentional.
This was important because tarot is an aesthetic and emotional product as well as a functional one. The visual identity, motion, language, and reading flow all had to reinforce the same promise.
From Experiment to Subscription Product
The one-page prototype grew into a full Next.js application with user accounts, saved product state, subscriptions, educational material, and multiple reasons to return.
I designed a freemium model that gives every user two readings per day while subscribers receive unlimited access. New users can understand the value without paying first, while frequent users have a clear reason to convert.
Stripe manages subscription payments and lifecycle, while Supabase handles authentication, database access, and row-level security. The system had to enforce entitlements reliably while protecting user data and keeping payment state synchronized with the product.
Creating More Than One Engagement Loop
A reading alone creates a useful interaction, but it does not automatically create a durable product.
I built card-meaning guides across love, career, health, and spirituality, giving users a structured way to explore the deck outside a generated reading. A tarot tutor supports people who want to learn to interpret cards themselves.
Editorial content also creates an organic discovery path into the product. Together, readings, reference material, learning tools, and articles give different users different reasons to arrive and return.
Owning the Complete Stack
I built LVX Tarot solo. The concept, brand, interface, GLSL environment, AI behaviour, Next.js application, Supabase data model, authentication, security rules, Stripe integration, content system, monetisation, and launch were all part of the same product decision-making process.
That end-to-end ownership matters because the layers constrain one another. Prompt design affects API usage. Usage affects pricing. Pricing affects entitlements. Entitlements affect database security. Waiting time affects interaction pacing. The visual atmosphere affects whether the experience feels valuable at all.
Rather than assembling disconnected services, I designed those relationships as one system.
The Outcome
LVX Tarot became a live consumer product with paying users instead of remaining an AI demo.
It proved that the original interaction had enough value to support accounts, repeat use, educational features, and a subscription model. It also gave me direct experience balancing model cost, free access, conversion, security, content, and product atmosphere.
The project shows a different range from my Web3 and Three.js client work. I can identify an opportunity without a brief, validate it with a small version, build the complete business and technical system, and ship something people choose to pay for.
That is the kind of development work I want to be hired for: owning an idea deeply enough that engineering, product, design, and commercial reality strengthen one another.