
Weekend Creative Challenge: Lumina AI — Imagine It, Create It, Play It
Meet Lumina AI — a creative AI workspace that turns imagination into something you can create, explore, and play. Generate stories and poems, brainstorm visual ideas, build game concepts, write playable game code, and iterate on your creations with multiple AI models. Deployed with AWS Amplify.
Create. Imagine. Inspire.
Lumina AI is a creative AI assistant designed to help people turn ideas into actual creative experiences. Instead of being limited to answering questions, Lumina provides a workspace where users can brainstorm, write, experiment, create projects, generate code, and turn ideas into something they can actually explore.
The idea behind Lumina is simple:
What if an AI assistant could help you go from a blank idea to a creative result?
Lumina brings conversations, projects, a personal library, model selection, and multiple AI providers into one interface.
Users can use Lumina for creative writing, storytelling, poetry, brainstorming, game creation, coding, idea development, and many other forms of creative expression.

Lumina AI creative workspace — a conversational interface for brainstorming, creating, experimenting, and turning ideas into useful creative outputs.
What Lumina AI Can Create
The Weekend Creative Challenge asks builders to create something creative involving words, images, sound, or play.
I designed Lumina to support multiple creative directions from a single conversational interface.
Creative Direction | What Lumina Can Do |
|---|---|
Story / Poem Generator | Generate stories, poems, characters, scenes, dialogue and creative writing |
Meme / Image Remixing | Develop meme concepts, captions, remix ideas and visual directions |
Playlist / Mood Board Maker | Develop moods, themes, playlist concepts and visual inspiration |
Game / Interactive Toy | Create game concepts, generate playable game code and let users interact with the resulting experience |
The game creation workflow is particularly important to Lumina's creative experience.
A user can describe a game idea in natural language, and Lumina can help turn that idea into working game code.
Instead of stopping at:
"Here is an idea for a game."
Lumina can continue toward:
Idea → Game concept → Code → Live playable experience
This makes the AI interaction much more tangible because users can immediately experiment with what the AI created.
For example, a user could ask Lumina to create a small browser game, define the rules and mechanics, generate the required code, and then use the resulting experience to test and play the game.
The user can then continue the conversation and ask Lumina to modify the game — changing the rules, difficulty, gameplay mechanics, characters, or other parts of the experience.
This creates an iterative creative loop rather than a one-time AI response.
From Idea to Interactive Game
One of the features I wanted Lumina to demonstrate is that AI-generated creativity does not have to remain inside a text response.
For interactive projects, Lumina can generate game code and provide a live playable experience.
The workflow looks like this:
Game Idea
↓
AI Planning
↓
Game Mechanics
↓
Code Generation
↓
Live Preview / Play
↓
User Feedback
↓
AI Iteration
↓
Improved Game.
This makes Lumina useful not only for people who want to write, but also for people who want to experiment with interactive ideas.
A user does not need to start with programming knowledge. They can describe what they want to build conversationally and use the AI to help transform that description into executable code and an interactive result.
How I Built It
Lumina AI was built as a modern React + Vite single-page application.
React handles the main user interface and application experience, while the application is structured into separate areas for authentication, conversations, projects, library data, settings and AI functionality.
I used React Context API and reducer-based state management to keep different application concerns separated instead of placing everything into one large state object.
The application maintains separate state areas for:
- Authentication
- Chats and messages
- Projects
- Library
- Application settings
This structure makes the application easier to extend as new creative capabilities are added.
For authentication and persistent application data, Lumina uses Firebase Authentication and Cloud Firestore. User-specific information is associated with authenticated users, while browser storage provides a local fallback when Firebase is not configured.
Multi-Model AI Architecture
A major design decision was to avoid tightly coupling Lumina to a single AI provider.
Lumina uses a provider-oriented architecture that separates the AI layer from the user interface.
The architecture includes:
- AI provider adapters
- Model metadata
- Model registry
- Intent classification
- Agent logic
- Tool registry
This allows the application to work with multiple AI providers while keeping the main creative interface consistent.
The architecture can work with providers such as:
- OpenAI
- Anthropic
- Google Gemini
- Groq
- Other compatible AI providers
This is useful because different creative tasks can benefit from different models.
For example, one model may be better suited for creative writing while another may be better suited for reasoning, coding or brainstorming.
AWS Architecture
Lumina AI is deployed as a public web application using AWS Amplify Hosting.
The production deployment connects the GitHub repository to AWS Amplify.
Amplify builds the React/Vite application using the production build command and publishes the resulting
dist directory.Production flow
User
│
▼
Lumina AI Web App
│
▼
AWS Amplify Hosting
│
├── GitHub Integration
├── Automated Build
├── HTTPS
└── Web Delivery
│
▼
Lumina Application
│
├── Firebase Authentication
├── Firebase Firestore
│
└── AI Provider Layer
├── OpenAI
├── Anthropic
├── Google Gemini
└── Other Providers
This allowed me to move the application from local development to a publicly accessible production environment without managing a traditional web server.

Lumina AI architecture and deployment flow, showing the application layer, AWS deployment infrastructure, data services, AI provider layer, and the path from GitHub to the live application.
AWS Services Used
The primary AWS service used for the live deployment is AWS Amplify Hosting.
The broader architecture is designed so Lumina can evolve toward a more complete serverless AWS backend.
AWS Service | Role in Lumina Architecture |
|---|---|
AWS Amplify Hosting | Production hosting, GitHub integration, automated builds and deployment |
AWS Lambda | Serverless backend/API execution for server-side AI orchestration |
Amazon Cognito | AWS-native authentication option for the serverless architecture |
Amazon DynamoDB | Serverless persistence for application data such as chats, projects and settings |
Amazon S3 | Storage for uploaded files, generated assets and exports |
AWS Secrets Manager | Secure management of server-side API credentials |
Amazon CloudWatch | Logging, monitoring and operational visibility |
For the current challenge deployment, AWS Amplify is the confirmed AWS service powering the live application.
The additional AWS services provide a scalable direction for expanding Lumina into a more complete AWS-native architecture.
This approach allowed me to keep the weekend implementation focused while designing an architecture that can scale beyond the initial prototype.
Development and Deployment Flow
The complete development workflow is:
Development
↓
React + Vite
↓
GitHub
↓
AWS Amplify
↓
Automatic Build
↓
Production Deployment
↓
Live HTTPS Application
The Vite production configuration uses:
npm run buildand produces:
dist/as the deployment output.
Using GitHub with Amplify also creates a straightforward CI/CD workflow for future updates.
Challenges I Encountered
One of the biggest challenges was designing a multi-model AI application without making the user interface complicated.
If every provider is implemented directly inside the chat interface, adding another provider can require changes throughout the application.
I addressed this by separating the provider layer from the main application and introducing provider adapters, model metadata, a registry and AI orchestration logic.
Another challenge was managing application state across conversations, projects, settings and the library.
I separated these responsibilities into dedicated contexts and reducers so each part of the application could evolve independently.
The game-generation experience introduced another challenge: generating code is not enough. The creative experience becomes much more useful when users can actually run and interact with the generated result.
This led to the idea of treating generated code as an interactive creative output rather than simply displaying it as text.
Finally, I needed to move the project from local development to a real production environment. Connecting GitHub to AWS Amplify provided a simple way to build and deploy the application publicly.
What I Learned
This challenge taught me that building a creative AI application is about more than connecting an AI API to a chat box.
The real value comes from the workflow around the AI.
I learned more about:
- React and Vite production builds
- GitHub-based CI/CD
- AWS Amplify Hosting
- Serverless architecture
- Multi-model AI integration
- Provider abstraction
- Authentication
- Persistent application data
- State management
- AI-powered code generation
- Interactive creative experiences
- Turning generated code into something users can actually test and play
The game-generation workflow was especially interesting because it changed the role of AI from simply producing an answer to helping produce something that the user can experience and iterate on.
Why Lumina AI Fits the Creative Challenge
The Weekend Creative Challenge encourages builders to create applications involving words, images, sound or play.
Lumina focuses on creative expression through AI-assisted generation and experimentation.
It can help users create:
Words
Stories, poems, characters, dialogue, concepts and other creative writing.
Images and Visual Ideas
Meme concepts, image-remix ideas, captions, visual directions and creative concepts.
Mood and Inspiration
Playlist concepts, themes, moods and mood-board ideas.
Play
Game concepts, gameplay mechanics and working game code that can be experienced as a live interactive creation.
The important difference is that Lumina is not designed around one fixed creative output.
It provides a conversational environment where users can start with an idea and keep iterating until they have something they actually want to use.
The Creative Loop
Lumina's core creative philosophy can be summarized as:
Imagine
↓
Describe
↓
Generate
↓
Experience
↓
Modify
↓
Create Again
For writing, the output can be a story or poem.
For visual creativity, it can be a meme concept or image-remix direction.
For mood creation, it can be a playlist or mood-board concept.
For interactive creativity, it can become code + a playable experience.
This makes the application suitable for experimentation even when the user does not begin with a fully formed idea.
Live Application
Try Lumina AI
Source Code:
The application is deployed publicly through AWS Amplify Hosting.
Conclusion
Lumina AI started as a weekend experiment around a simple question:
Can an AI assistant help people move from an idea to an actual creative experience?
The result is a conversational creative workspace that combines AI models, projects, conversations, a personal library and interactive creation workflows.
Users can write stories and poems, brainstorm visual ideas, develop moods and concepts, create game ideas, generate game code and interact with the resulting experience.
AWS Amplify provided the deployment layer that turned the project from a local application into a publicly accessible web application.
The architecture also provides a path toward deeper AWS integration using services such as Lambda, S3, DynamoDB, Cognito, Secrets Manager and CloudWatch as the application evolves.
The most important lesson from the challenge was that creativity becomes more powerful when the AI is part of an iterative loop:
Create. Imagine. Inspire.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article