-
-
Splash
DumDoors: When Bad Decisions Meet AI Comedy
Inspiration
The idea for DumDoors hit our team during one of those late-night brainstorming sessions where we found ourselves watching "World's Dumbest Criminals" compilations at 2 AM. We were simultaneously cringing and laughing at people making spectacularly poor life choices when it struck us – what if we could create an AI that not only predicts the worst possible decisions in any scenario but roasts you for even considering them?
We've always been fascinated by the gap between human logic and human behavior. We all know what the "right" choice is most of the time, but we still manage to pick the option that leads to the most chaos. We wanted to build something that could capture that beautifully flawed human tendency while making people laugh at their own potential stupidity.
The final push came when we realized how much we all need to laugh at ourselves, especially in a world that takes everything so seriously. DumDoors became our answer to the question: "What if making terrible decisions could actually be fun?"
What it does
DumDoors is an AI-powered decision-making game that presents users with absurd scenarios and challenges them to identify both the WORST and BEST possible responses. But here's the twist – our AI doesn't just tell you if you're right or wrong. It delivers a brutally honest, hilariously sarcastic roast of your decision-making skills.
The game works like this:
- Players are presented with ridiculous scenarios (like "You're allergic to laughter and attending a stand-up show")
- They choose what they think is the worst possible response from multiple options
- Our custom-trained AI model evaluates their choice and delivers a personalized roast
- The AI explains why their choice was either brilliantly terrible or disappointingly sensible
- Players get a "DumStone" (like a tombstone) with their AI-generated roast as a shareable memento
- A leaderboard tracks who consistently makes the most entertainingly bad choices
The magic happens in how the AI understands context, humor, and the delicate art of constructive mockery. It's not just random insults – it's tailored comedy that actually makes you think about decision-making patterns while having a blast.
How we built it
Building DumDoors was like assembling a comedy club, a psychology lab, and a tech startup all at once. Here's how it came together:
The Architecture
We designed a microservices architecture that could handle the complexity of real-time AI interactions:
- Frontend: Built with React + TypeScript using Vite for lightning-fast development. Used Tailwind CSS for rapid prototyping of the game interface
- Backend: Go-based API server handling WebSocket connections for real-time gameplay and user sessions
- AI Service: Python FastAPI service that interfaces with our custom models and handles all the AI magic
- Databases:
- Neo4j for storing complex relationship data between scenarios, decisions, and user patterns
- MongoDB for game state and user data
- Redis for caching and session management
The AI Brain
The real challenge was training an AI that could be funny, insightful, and consistently entertaining:
Dataset Creation: We spent weeks crafting training datasets with thousands of scenarios and corresponding "roasts." Each entry needed to balance humor with insight, teaching the AI to recognize patterns in human decision-making while maintaining comedic timing.
Model Training: Using Google Cloud Platform and Vertex AI, we trained custom models specifically for:
- Scenario difficulty assessment
- Decision quality evaluation
- Personalized roast generation
- Context-aware humor adaptation
The Comedy Algorithm: The trickiest part was teaching an AI to be funny without being mean. We implemented multiple layers of evaluation: $$\text{Roast Quality} = \alpha \cdot \text{Humor Score} + \beta \cdot \text{Insight Value} - \gamma \cdot \text{Meanness Penalty}$$
Development Tools
Kiro IDE was absolutely game-changing for this project. Having an AI-powered development environment meant we could rapidly prototype features, get instant feedback on our code architecture, and even brainstorm creative scenario ideas. Kiro's ability to understand context across multiple files helped us maintain consistency in the codebase while juggling React components, Python AI services, and Go backend logic simultaneously. It was like having a senior developer pair programming with our team 24/7.
The AI assistance in Kiro particularly shined when we were debugging the complex interactions between our microservices. Instead of spending hours tracing WebSocket connections or figuring out why our Neo4j queries weren't returning expected results, Kiro could analyze the entire codebase and point us toward solutions in minutes.
Integration Challenges
Connecting everything required careful planning:
- Docker Compose for local development with hot reloading
- Cloudflare tunnels for external access during development
- Railway for initial deployment testing
- Basic monitoring for the AI service performance
However, we discovered that Reddit's devvit platform has specific constraints that prevented us from deploying our full backend architecture as intended.
Challenges we ran into
The "Funny vs. Offensive" Tightrope
The biggest challenge was training an AI to be hilariously savage without crossing into genuinely hurtful territory. We went through dozens of iterations, fine-tuning the model's response patterns. Early versions were either too bland ("Your choice was suboptimal") or occasionally too harsh. Finding that sweet spot where the AI could deliver cutting comedy while still being playful took months of refinement.
Real-time AI Performance and Platform Constraints
Getting reasonable response times from AI models while maintaining quality was challenging. The initial implementation had long delays that hurt the game experience. We worked on:
- Caching strategies in Redis
- Model optimization for faster inference
- Fallback mechanisms for service issues
- Load balancing approaches
However, Reddit's platform restrictions meant we had to significantly adapt our backend architecture, ultimately running most functionality through the frontend with limited backend capabilities.
Database Design for Chaos
Storing the relationships between scenarios, user choices, personality patterns, and AI-generated content in a way that made sense was like solving a 4D puzzle. Neo4j was perfect for the relationship mapping, but integrating it seamlessly with MongoDB for session data and ensuring consistency across services required careful transaction management.
The Scenario Shuffle Problem
Users were encountering the same scenarios repeatedly, which killed replayability. We had to implement a sophisticated queue system that:
- Shuffles scenarios when loaded from CSV
- Ensures no repeats until all scenarios are exhausted
- Maintains state across user sessions
- Gracefully handles new scenarios being added to the dataset
Accomplishments that we're proud of
The AI Actually Gets Funnier Over Time
Through prompt engineering and testing, the AI developed a consistent comedic personality. It can adapt its roasting style based on user choices, though we're still refining this feature.
Sub-Second Response Times
After weeks of optimization, we managed to get reasonably fast response times for AI-generated roasts. The combination of model optimization and caching helps keep the conversation flowing smoothly.
The DumStone Feature
The tombstone-style "DumStone" feature provides users with a personalized summary after each game session. The engraved stone aesthetic with custom epitaphs makes the results shareable and memorable.
Zero-Downtime Architecture
The microservices architecture helped during development, allowing us to work on different components independently. However, due to Reddit's platform limitations, we weren't able to fully deploy the backend services as originally planned. The current implementation runs primarily on the frontend with some backend features adapted for the devvit environment.
What we learned
AI Comedy is Harder Than Human Comedy
Teaching a machine to be funny showed us how complex humor really is. It involves understanding context, timing, and social dynamics. Getting the AI to be consistently funny without being offensive required a lot of trial and error.
Microservices Are Worth the Complexity
While the initial setup was more complex than a monolithic approach, the ability to scale and update individual services independently saved countless hours during development and deployment. When the AI service needed major updates, the game could keep running on cached responses.
User Experience Trumps Technical Perfection
We spent time optimizing database queries when users were actually more concerned about seeing repeated scenarios. This taught us to focus on user experience over technical perfection.
The Power of AI-Assisted Development
Working with Kiro IDE was helpful for full-stack development. Having an AI assistant that could understand our codebase and suggest improvements made development smoother, especially when juggling multiple services and debugging complex interactions.
What's next for DumDoors
Multiplayer Madness
We're working on real-time multiplayer scenarios where friends can compete to make the worst decisions simultaneously. Imagine trying to out-stupid your friends while an AI roasts all of you in real-time. The social dynamics alone will be comedy gold.
Personality Profiling
The AI is getting better at recognizing personality patterns in decision-making. Soon, DumDoors will offer detailed "Decision-Making Personality" reports that are both hilarious and surprisingly insightful. Think Myers-Briggs, but for your capacity to make terrible choices.
Scenario Generation AI
Instead of relying on manually crafted scenarios, we're training a separate AI model to generate new scenarios based on current events, user preferences, and trending topics. This will keep the content fresh and relevant while maintaining the quality standards.
Integration with Real Decision-Making
The ultimate goal is to create a companion app that can provide gentle (and funny) guidance for real-world decisions. Imagine getting a notification like: "Based on your DumDoors history, you have a 73% chance of ordering the spiciest menu item and immediately regretting it. Proceed with caution."
Reddit Integration Expansion
With the devvit platform integration already in place, we're planning deeper Reddit community features. Subreddit-specific scenarios, community-generated content, and Reddit-wide leaderboards will turn DumDoors into a social phenomenon.
DumDoors proves that sometimes the best way to make good decisions is to first understand all the hilariously bad ones. In a world full of serious choices, maybe what we really need is an AI that can make us laugh at our own terrible judgment.
Tech Stack: TypeScript React Python Go HTML CSS Vite Tailwind FastAPI Flask WebSocket REST Neo4j MongoDB Redis GCP VertexAI Railway Cloudflare Docker Compose Nginx Prometheus Grafana Reddit Pandas NumPy JSONL CSV Linux VSCode Git Shell Docker Air ESLint Prettier Vitest Kiro
Log in or sign up for Devpost to join the conversation.