Saachi K. Gupta

Halloween Costume Generator — Vibe-Based Search

2025-11-01

A Halloween costume discovery tool that started as a generative AI project and ended up as a curated database with a quiz-style interface. Sometimes the simpler solution is the better one—and sometimes the real opportunity is in what comes after discovery.

Live demo →

Highlights

Technical Deep Dive

The Pivot: From AI Generation to Curated Discovery

My original plan was to use Claude's API to generate costume suggestions based on user-inputted vibes. Someone types "spooky but elegant" and the AI suggests "Victorian ghost" or "witch in couture." It sounded perfect for a workshop focused on AI tools.

But when I started building, the problems became obvious: API calls take time, cost money (even small amounts add up at scale), and return unpredictable results. Would "spooky elegant" give the same suggestions twice? More importantly—did the problem actually need generative AI, or was I reaching for it because it was trendy?

The answer was no. What people actually need isn't a conversation with an AI—it's a fast, fun way to browse costume ideas that match their vibe. So I pivoted completely: build a database of costume ideas, tag them richly with aesthetic keywords, and create a quiz interface that feels intelligent without any API overhead.

Why I Deliberately Didn't Use AI: The Creative Control Problem

Beyond the technical reasons (cost, speed, reliability), there was a deeper concern that made me hesitant to use generative AI for costume suggestions: I couldn't guarantee what it would generate.

Halloween costumes are a minefield of potential offense. Cultural appropriation, insensitive stereotypes, inappropriate suggestions for kids who might use the app—these aren't edge cases, they're real risks. If I used an AI API to generate costume ideas on the fly, I'd be ceding creative control over what gets suggested. Sure, I could add guardrails and content filters, but:

With a curated database, I have complete control. Every costume that shows up is one I've personally reviewed and decided belongs in the collection. I can ensure it's broadly age-appropriate (or at least not explicitly inappropriate). I can avoid costumes that punch down or rely on harmful stereotypes. I can make judgment calls about what's clever satire versus what's just offensive.

This isn't about being overly cautious—it's about taking responsibility for what my app puts into the world. When you curate, you're accountable. When you generate, you're rolling the dice. For something as culturally loaded as Halloween costumes, I wanted that accountability.

The tradeoff: My database caps at 468 costumes instead of infinite AI-generated possibilities. But those 468 are costumes I actually stand behind. That felt more important than scale.

Key Architectural Decisions

Multi-Tag Matching Over Semantic Search

I could have used vector embeddings and semantic search to find "similar" costumes. But that would have required a vector database, additional complexity, and honestly—overkill for a workshop project with a few hundred costumes.

Instead: simple tag matching with a scoring algorithm. Each costume has 3-10 tags from a taxonomy of 313 aesthetic keywords (PopCulture, SwiftieCore, GothicWestern, CapitalistCamp, ExistentialHumor, etc.). Users select their vibes across two rounds, and costumes are ranked by how many matching tags they have. It's deterministic, fast, and explainable—you can see exactly why a costume matched.

The Tag Taxonomy: Curation as Product

The real work wasn't the code—it was building the tag taxonomy. I started with basic categories (Funny, Scary, Group, DIY) but quickly realized these were too generic. The magic happened when I leaned into internet culture and hyper-specific aesthetics:

These tags do two things: they help the matching algorithm, but more importantly, they're fun to read. "DoomScrollEnergy" tells you more about the vibe than "Internet Culture" ever could. The specificity is the point.

Client-Side Everything (For Now)

The entire app runs client-side with localStorage for ratings persistence. No backend, no database calls, instant load times. The 468 costumes live in a TypeScript file as a JSON array—simple, fast, and zero hosting costs beyond static files.

The tradeoff: I can't gather analytics on which tags are actually popular, can't A/B test the quiz flow, and can't do any server-side personalization. But for a workshop prototype? This was the right call. Ship fast, validate the concept, add complexity later if needed.

Spirit Halloween Aesthetic as Constraint

I spent significant time making the UI feel like a Spirit Halloween costume package—the orange and white split, the curved red divider, the circular badges. This wasn't just decoration; it was a design constraint that forced cohesion. Instead of endless tweaking, I had a clear reference: "Does this feel like opening a costume package?" If yes, keep it. If no, cut it.

What I Learned About Feature Scope

The workshop time limit forced brutal prioritization. I wanted to add: user accounts, social sharing, costume boards, AI-generated costume variations, weather-appropriate filtering, budget ranges, and more. All reasonable. None essential.

What shipped: a two-round quiz that surfaces 10 matching costumes with a rating system. That's it. And it works. The lesson: the MVP is smaller than you think. Everything else is nice-to-have until you validate that people actually want the core thing.

The Community Rating System

I added a 0-5 flame rating system that persists to localStorage. As people rate costumes, two tickers appear on the main screen: "Trending" (most flames) and "Needs Love" (fewest flames). This creates a feedback loop—popular costumes get more visibility, which generates more ratings, which surfaces community favorites.

It's fake community (all ratings are stored locally per user, not aggregated), but it feels social. And if this scaled, those ratings would be incredibly valuable data for understanding what actually resonates.

What I Deliberately Didn't Do (And Why)

The Big Opportunity: Discovery → Purchase

Here's the thing: this app solves the delight of discovery, but leaves money on the table. People find costumes they love, get excited, then... have to Google where to buy the pieces themselves. That's where the conversion drops.

Why Shopping Integration Would Change Everything

Imagine if after rating a costume 5 flames, you saw: "Shop the look" with affiliate links to Amazon, Spirit Halloween, or costume retailers showing the actual items you need. Suddenly this isn't just a fun quiz—it's a conversion machine.

The technical path: For each costume, maintain a structured list of required items (e.g., "Cowboy Ken" needs: cowboy hat, denim vest, bandana, boots). Use affiliate APIs (Amazon Associates, ShareASale, etc.) to pull real products matching those items. Display them with prices, ratings, and direct purchase links.

The business model: 3-8% commission on every purchase. If 10,000 people use this app in October and 5% buy something (average order $50), that's $750-2,000 in affiliate revenue from a weekend project. And October traffic for "Halloween costume ideas" is massive and predictable.

Why I Didn't Build It (Yet)

Time constraint was the obvious reason—the workshop was one evening. But the real reason: I wanted to validate the discovery experience first. Does the quiz format work? Do people engage with the ratings? Do the aesthetic tags resonate? Adding shopping too early would have meant splitting focus between two hard problems: discovery UX and e-commerce integration.

Now that the core works, shopping is the obvious next feature. And unlike most features, this one directly generates revenue—it pays for itself.

Next Steps & Future Ideas

Make It Shoppable (Priority #1)

Community Features

Enhanced Discovery

Maybe AI Has a Role After All

Now that the core works without AI, there are specific places where it could add value:

But these are enhancements, not foundations. The app proves its value first, then AI makes it 10-20% better in targeted ways.

Tech Stack

Key Learnings

Lesson 1: Question the AI assumption. I went into this workshop expecting to use generative AI because that was the theme. But the problem didn't need it. A well-organized database with smart tagging was faster, cheaper, more reliable, and actually better for users. Don't use AI because it's trendy—use it when it solves a problem better than alternatives.

Lesson 2: Creative control matters for culturally sensitive content. Halloween costumes require judgment calls about taste, appropriateness, and potential offense. Ceding that control to an AI felt irresponsible. With curation, I'm accountable for every suggestion. The tradeoff is scale, but 468 thoughtful costumes beats infinite unpredictable ones.

Lesson 3: Curation is underrated in the age of infinite content. Anyone can generate 10,000 costume ideas with AI. But thoughtfully curating 468 costumes with hyper-specific aesthetic tags that actually capture internet culture? That's the product. The personality in tags like "DoomScrollEnergy" and "CapitalistCamp" is what makes this feel human and fun.

Lesson 4: The money is in the next step. Discovery is delightful, but conversion is how you build a business. This app proves people want help finding costumes—now the opportunity is helping them actually buy them. The path from "I love this costume" to "I just bought it" is where value (and revenue) lives.

Lesson 5: Constraints clarify. Having one evening forced me to ship the core loop: quiz → results → ratings. Everything else—accounts, social, AI variations—got cut. And the result is better for it. Start with the smallest thing that could work, not the biggest thing you can imagine.

Lesson 6: Build what you'd actually use. I made this because I genuinely get decision paralysis around Halloween costumes. The hyper-specific tags ("ExistentialSnack," "RhinestoneDiplomacy") are things I'd actually search for. That authenticity shows. Build for yourself first, then find others who think like you.