Build and Validate a Quest Generator

Build an AI quest generator in Lovable and validate it with real users.

Introduction

30 Second Summary

You have all the freedom in the world as a digital nomad. Yet somehow, most evenings end with scrolling and Netflix instead of actually exploring the city outside your door.

In this project, you will build a working AI-powered quest generator that creates personalized real-world sidequests for solo travelers. You will also take it to a coworking space to test with real people and gather validated interview data for your AI Squads badge.

What You'll Build

A mobile-friendly web app built in Lovable that takes a user's mood, available time, budget, and location, then calls the Claude API through a secure Edge Function to generate a personalized sidequest with a fun buddy voice.

By the end of this project, you'll have:

  • A deployed quest generator accessible on your phone, powered by Claude's API.
  • A tested system prompt that gives your AI a distinct buddy personality and generates contextual, actionable quests.
  • Validated interview notes from 3+ real conversations using Mom Test techniques, structured for your AI Squads badge submission.
  • Secret Mission: Add quest history storage so you can spot patterns in what the AI generates and how users react.

Are there any prerequisites?

You need a Lovable Pro account and a Claude API key with credits (the $5 minimum purchase is more than enough for this project). You should also have access to a coworking space or public area where you can talk to 3+ people.

Set Up Lovable Cloud and Store Your Claude API Key

Your quest generator will call the Claude API to create personalized sidequests. Before you build anything, you need a project and a secure way to store your API key so it never appears in your frontend code.

Lovable Cloud gives you a backend with Edge Functions and Secrets built in. In this step, you'll create a project and store your Claude API key where only server-side code can access it.

In this step, get ready to:
  • Create a new Lovable project.
  • Enable Lovable Cloud for your backend.
  • Store your Claude API key as an encrypted secret.
Create a new Lovable project
  • Open your browser and go to lovable.dev.
  • Sign in to your Lovable Pro account.
  • Click New Project (or the "+" button on your dashboard).
  • Name your project sidekick-quest-gen.

You should see the Lovable editor open with your new empty project.

Enable Lovable Cloud

Lovable Cloud provides your project with a managed backend. This includes Edge Functions (server-side code), Secrets (encrypted environment variables), and a database. You need it enabled so your Edge Function can securely call the Claude API.

  • In the Lovable editor, look for the Cloud section in the left sidebar or bottom panel.
  • If Lovable Cloud is not already enabled for your project, click Enable Cloud and follow the prompts.
  • Select a region close to your location when prompted.

What is Lovable Cloud?

Lovable Cloud is a built-in backend powered by Supabase. It gives your project Edge Functions (server-side TypeScript that runs on Deno), encrypted Secrets, and a database. No separate Supabase signup or configuration is needed.

For many workspaces, Lovable Cloud is enabled by default with the "Always allow" setting. If yours is already active, you will see the Cloud panel without needing to click anything extra.

Why use your own Claude API key?

Lovable has a built-in AI connector that manages keys for you. However, using your own Claude API key gives you full control over the system prompt, model selection, and billing. This is the exact pattern you will reuse when building your full MVP.

Store your Claude API key as a secret

Secrets in Lovable Cloud are encrypted and only accessible to Edge Functions on the server side. Your key will never appear in your frontend code or be visible to users.

  • In the Lovable editor, click Cloud to open the Cloud panel.
  • Select Secrets.
  • Click Add Secret (or the "+" button in the Secrets panel).
  • Enter ANTHROPIC_API_KEY as the secret name.
  • Paste your Claude API key as the value.
  • Click Save to store the secret.

You should see ANTHROPIC_API_KEY listed in the Secrets panel. The value is hidden and encrypted.

How does your Edge Function access the secret?

When you create an Edge Function in the next step, it will read this key using Deno.env.get("ANTHROPIC_API_KEY"). The secret is automatically injected into the Edge Function environment at runtime. It never touches the browser or your frontend bundle.

Don't see a Secrets option?

Make sure Lovable Cloud is enabled for your project first. The Secrets panel only appears after Cloud is active.

If you see an error about reserved prefixes, double-check that your secret name is exactly ANTHROPIC_API_KEY with no SUPABASE_ or LOVABLE_ prefix. Those prefixes are reserved by Lovable.

help me troubleshoot why my secret isn't saving in Lovable Cloud

Your project is set up and your Claude API key is securely stored. Next, you'll build the quest generator UI and wire it up to an Edge Function that calls the Claude API.

Build the Quest Generator UI and Edge Function

Your backend is ready. API key stored, Cloud enabled, secrets locked down.

Now it's time to build the actual app. You'll prompt Lovable to generate a mobile-first quest generator interface, then create a secure Edge Function that calls the Claude API on the server side. Lovable handles the code generation, deployment, and wiring for you.

In this step, get ready to:
  • Build the mobile-first quest generator UI with input fields, a generate button, and a quest display area.
  • Create an Edge Function that securely calls Claude's API with your stored key.
  • Connect the frontend button to the Edge Function and test the full flow.
Prompt Lovable to build the quest generator UI

Your quest generator needs to capture four pieces of context from the user: mood, available time, budget, and location. It also needs a display area for the generated quest.

  • In the Lovable chat panel, paste the following prompt to build your UI:
Build a single-screen mobile-first quest generator app with these elements:

1. INPUT SECTION:
- Mood selector (dropdown or emoji picker) with options: adventurous, chill, social, spontaneous
- Time available selector with options: 15 min, 30 min, 1 hour, half day
- Budget selector with options: free, under $10, under $30
- Location text input that defaults to "Bansko, Bulgaria"

2. ACTION:
- A "Generate Quest" button

3. QUEST DISPLAY AREA:
- Quest description text
- Category tag (adventure, social, culture, or dare)
- Estimated time and cost for the quest

4. STATES:
- Loading state while waiting for the API response
- Error state with a friendly message if something goes wrong

5. VISUAL STYLE:
- Dark theme with a game-like XP-badge aesthetic
- Fun, energetic feel - think RPG quest log meets mobile app
- Make it look great on a phone screen

What does this prompt do?

This prompt tells Lovable exactly what UI components to generate. Lovable will create a React component with Tailwind CSS styling, all deployed automatically.

The key details are the specific input options (adventurous, chill, social, spontaneous for mood) and the dark game-like visual style. Without these specifics, Lovable would make generic design choices.

  • Wait for Lovable to generate the UI. This takes 30-60 seconds.
  • Check the preview panel on the right side of the Lovable editor. You should see a dark-themed interface with your four input fields, the generate button, and an empty quest display area.

Preview not showing the inputs?

If Lovable generates something that doesn't match your expectations (wrong inputs, missing fields, different style), type a follow-up message in the chat describing what needs to change. For example: "The mood selector should be a dropdown with exactly these options: adventurous, chill, social, spontaneous."

Lovable iterates on its own generated code, so corrections are quick.

Help me fix my Lovable UI prompt

Create the Edge Function for Claude API calls

The Edge Function is your secure backend. It runs on the server, reads your API key from secrets, and calls Claude's Messages endpoint. Your frontend never touches the API key directly.

  • In the Lovable chat, paste this prompt to create your Edge Function:
Create a Supabase Edge Function called "generate-quest" that does the following:

1. Receives a POST request with JSON body containing: mood, time_available, budget, location
2. Reads the ANTHROPIC_API_KEY from environment using Deno.env.get("ANTHROPIC_API_KEY")
3. Calls the Anthropic Messages API at https://api.anthropic.com/v1/messages with:
   - Model: claude-sonnet-4-6
   - A system prompt that defines a fun buddy personality for generating quests (I will refine this prompt in the next step)
   - A user message containing the mood, time_available, budget, and location
4. Parses the response and returns a JSON object with: quest_description, category (one of: adventure, social, culture, dare), estimated_time, estimated_cost
5. Handles errors gracefully - if the API call fails, return a friendly error message instead of crashing

Use the x-api-key header for Anthropic authentication and set anthropic-version to "2023-06-01". Set max_tokens to 1024.

What does this Edge Function do?

`Deno.env.get("ANTHROPIC_API_KEY")` reads your stored secret on the server side. The key never leaves the backend.

The function calls Claude's Messages API with the model claude-sonnet-4-6. This model is ideal for creative generation tasks like writing quests with personality. At roughly $3 per million input tokens, each quest generation costs a fraction of a cent.

Why an Edge Function instead of calling Claude directly from the browser?

If your frontend called the Claude API directly, your API key would be exposed in the browser's network tab. Anyone could steal it and run up charges on your account.

Edge Functions run server-side. They keep secrets hidden and give you a single secure gateway between your app and external APIs.

  • Wait for Lovable to generate and deploy the Edge Function. You should see a confirmation in the chat that the function was created.

Edge Function not deploying?

Check the Cloud tab in the Lovable editor. If you see an error, click into Logs for the specific error message. The most common issue is a typo in the secret name.

Verify that your secret is named exactly ANTHROPIC_API_KEY in the Secrets panel. The Edge Function code must reference the same name with Deno.env.get("ANTHROPIC_API_KEY").

Help me debug my Edge Function deployment in Lovable

Wire the frontend to the Edge Function and test

The UI exists. The Edge Function exists. Now you need to connect them so clicking the button triggers the function and displays the result.

  • In the Lovable chat, paste this prompt to connect everything:
Wire the "Generate Quest" button to call the generate-quest Edge Function. When the user clicks the button:
1. Show the loading state
2. Send the current values of mood, time_available, budget, and location to the Edge Function
3. When the response comes back, display the quest_description, category tag, estimated_time, and estimated_cost in the quest display area
4. If there's an error, show a friendly error message instead of the quest
5. Hide the loading state when done

What happens behind the scenes?

Lovable generates frontend code that invokes your Edge Function when the button is clicked. The function receives the user's inputs, calls Claude, and returns the quest data. The frontend then renders the response in your quest display area.

  • In the Lovable preview panel, select a mood, time, and budget from the dropdowns.
  • Leave the location as the default (Bansko, Bulgaria).
  • Click Generate Quest.
  • You should see a loading state appear, then after a few seconds, a quest with a description, a category tag, and time/cost estimates.

Getting an error when you click Generate Quest?

If you see a friendly error message in the UI, the Edge Function is running but the Claude API call is failing. Check these things:

  • Your ANTHROPIC_API_KEY secret must contain a valid key with credits. If your key has no credits, the API will reject the request.
  • Open the Cloud tab and check Logs. The error message will tell you exactly what went wrong (invalid key, rate limit, incorrect model name).
  • If the button does nothing at all (no loading state, no error), the wiring between the frontend and Edge Function is broken. Ask Lovable: "The Generate Quest button isn't calling the Edge Function. Can you check the connection and fix it?"

Help me fix my quest generator Edge Function error

Your quest generator is live. The frontend captures user inputs, the Edge Function securely calls Claude, and the result displays on screen. Next up, you'll craft the system prompt that gives Sidekick its distinct buddy personality.

Craft the Sidekick Buddy System Prompt

Your quest generator works end-to-end, but the quests it produces feel generic. That is because the Edge Function is using a placeholder system prompt that does not tell Claude how to speak or what makes a good quest.

The system prompt is the creative core of your product. It defines what makes Sidekick feel different from a generic AI chatbot. In this step, you will write a prompt that gives your buddy a distinct personality, then test it against real input combinations until the quests feel genuinely fun.

In this step, get ready to:
  • Write a system prompt that defines the Sidekick buddy personality and quest format.
  • Prompt Lovable to integrate the system prompt into your Edge Function.
  • Test and iterate with at least 6 input combinations until quests feel distinct and doable.
Write your Sidekick buddy system prompt

A system prompt tells Claude who it is, how it should respond, and what format to use. Think of it as the personality blueprint for your AI buddy.

Your system prompt needs to cover five elements. Write it in a text editor or note app first so you can iterate on it before pasting it into Lovable.

  • Open any text editor (Notes, a new browser tab, or a blank document) and start writing your system prompt using these five elements:
  • Personality: The buddy is encouraging, slightly cheeky, speaks casually like a friend who is dragging you out the door. Not corporate. Not overly enthusiastic. Think "your most adventurous friend who knows the city."
  • Quest format: Each quest must include a clear action (what to do), a reason (why it is fun or interesting), a first step (the smallest possible action to start), and a category (adventure, social, culture, or dare).
  • Constraints: The quest MUST match the user's stated time, budget, and mood. If they say "15 minutes, free" do not suggest a full-day hike. If they say "social" lean toward quests involving talking to at least one stranger.
  • Location awareness: Use the location to suggest specific types of places (cafes, mountains, old town streets) without inventing specific business names that may not exist.
  • Tone: Short, punchy, direct. No AI filler phrases like "certainly!" or "great question!". The buddy speaks in 2-3 sentences max for the quest, then one sentence for the first step.

What makes a good system prompt here?

The personality section is what separates your product from a generic "give me activity ideas" ChatGPT prompt. The constraints section prevents the AI from ignoring the user's inputs. The tone section kills AI slop before it starts.

Use your own taste as a nomad. If a quest sounds like something a travel blog would suggest, rewrite the personality section to push harder on the "cheeky friend" angle.

✔️ I'll give it a go!

Write your system prompt covering all five elements. Aim for a prompt that is 150-300 words total. You will test it shortly and can iterate from there.

ⓧ Maybe a little help...

Here is an example system prompt you can use as a starting point. Customize the personality and phrasing to match your own voice:

You are Sidekick, a slightly cheeky adventure buddy who talks like a friend dragging someone out the door. You are encouraging but never corporate or over-enthusiastic. Think: their most adventurous friend who knows the city.

When given a user's mood, available time, budget, and location, generate ONE sidequest.

Format your response as JSON with these fields:
- quest: The quest description in 2-3 sentences max. Be specific and actionable.
- reason: One sentence on why this is fun or interesting.
- first_step: One sentence describing the smallest possible action to start right now.
- category: One of: adventure, social, culture, dare.
- estimated_time: Match the user's stated time.
- estimated_cost: Match the user's stated budget.

Rules:
- NEVER suggest something that exceeds the user's time or budget.
- If mood is "social", the quest must involve interacting with at least one stranger.
- Use the location to suggest types of places (cafes, trails, old town streets) but NEVER invent specific business names.
- No AI filler phrases. No "certainly!", "great question!", "I'd be happy to". Just be direct.
- Speak like a friend, not a tour guide. Short sentences. Punchy.

What does this prompt do?

The opening paragraph establishes personality. The JSON format section tells Claude exactly how to structure its response so your frontend can parse it. The rules section prevents common AI failures like ignoring constraints or being generic.

Feel free to adjust the personality lines and add your own rules. This is YOUR product voice.

Integrate the system prompt into your Edge Function

Now that you have your system prompt written, you need to tell Lovable to use it in the existing Edge Function. Lovable will update the function code for you.

  • In the Lovable chat, paste a prompt like the following (replacing the system prompt text with your own):
Update my generate-quest Edge Function to use this system prompt when calling Claude:

[Paste your full system prompt here]

Make sure the system prompt is sent as the system parameter in the Claude API call. Keep the model as claude-sonnet-4-6. The user message should contain their mood, time_available, budget, and location values. Parse Claude's response as JSON and return it to the frontend.

What happens when you send this?

Lovable reads your prompt, updates the Edge Function code to include your system prompt as a constant, and redeploys the function automatically. The frontend does not change because it already calls this function.

Your system prompt is stored server-side in the Edge Function code. It never reaches the browser, keeping your product logic private.

  • Wait for Lovable to finish updating the function. You should see a success message in the chat confirming the Edge Function was redeployed.

Edge Function not updating?

If Lovable says the update failed, check that you did not accidentally include curly quotes or special characters in your system prompt. Plain straight quotes work best.

If the function deploys but returns errors, check the Edge Function logs under Cloud in the Lovable sidebar. The error message usually points to a JSON parsing issue in Claude's response.

help me debug my Edge Function error in Lovable

Test and iterate with different input combinations

A system prompt only works if it produces good results across different inputs. You need to test at least 6 combinations to catch issues like the AI ignoring budget constraints or generating bland quests for certain moods.

  • In the Lovable preview, click Generate Quest with the following combination: mood set to chill, time set to 15 min, budget set to free, location set to Bansko, Bulgaria.
  • Generate a second quest with: mood set to adventurous, time set to 1 hour, budget set to under $10, location set to Bansko, Bulgaria.
  • Generate a third quest with: mood set to social, time set to 30 min, budget set to free, location set to Bansko, Bulgaria.
  • Generate 3 more quests with different combinations of your choice. Try spontaneous mood, half day time, and under $30 budget to cover the edges.

For each quest, ask yourself: would YOU do this quest if someone handed it to you right now? If the answer is no, your system prompt needs iteration.

What to look for when evaluating quests

  • Each quest should feel distinct from the others. If "chill" and "adventurous" produce similar quests, your personality section needs stronger differentiation.
  • The time and budget constraints should be respected. A "15 min, free" quest should not require buying anything or traveling far.
  • The tone should sound like a friend, not a travel blog. If you see phrases like "embark on a journey" or "discover the hidden gems", tighten your tone rules.
  • The "social" mood should always involve another person. If it suggests a solo activity, add a stronger constraint to your prompt.
  • If any quests feel generic or wrong, update your system prompt in Lovable chat. Tell Lovable what is not working and paste your revised prompt. Repeat until all 6 test combinations produce quests that feel specific and doable.

Iterate in small batches

Change one section of your system prompt at a time (personality OR constraints OR tone). Testing after each change makes it clear what improved the output versus what broke it.

Quests feel too generic?

The most common cause is a personality section that is too vague. Instead of "be fun and casual", try specific instructions like "speak in short sentences, use words like 'alright' and 'let's go', never use exclamation marks more than once."

Another common issue is missing constraint enforcement. If Claude ignores budget or time, add explicit rules like "If budget is 'free', the quest must cost exactly zero money. No exceptions."

help me improve my system prompt so Claude generates more specific and varied quests

Your system prompt is now dialed in and producing quests with real personality. Next up, you will prepare your interview approach so you can show this prototype to real people at the Lounge and gather feedback for your badge.

Prepare Your Interview Approach

Your quest generator is live, generating real quests powered by your custom Sidekick buddy personality. That means the hardest technical piece of your MVP is already done.

Now you need to find out whether anyone actually wants this. You have 3+ conversations to complete for your AI Squads badge, and you have a secret weapon most founders skip: a working prototype you can show people in real time. Showing something is infinitely easier than pitching something.

In this step, get ready to:
  • Prepare your opening line that uses the prototype as an icebreaker.
  • Learn the Mom Test follow-up questions to ask after showing the quest.
  • Set up a note-taking framework to capture real user data.
Your opening line

The prototype removes the awkwardness of approaching strangers. You are not pitching an idea or asking for opinions. You are showing something real and watching for a genuine reaction.

  • Walk up to someone at the Lounge who looks like they are between tasks.
  • Say: "Hey, I am testing something I built. It takes 30 seconds. Can you tell me your mood and how much free time you have?"
  • Pull up the app on your phone, input their answers, and show them the quest it generates.
  • Watch their face. That reaction is your data.

Why show instead of pitch?

When you pitch an idea, people give you polite encouragement. When you show them something real, you get genuine reactions. A confused squint, an excited "oh wait, I'd actually do this", or a polite shrug all tell you something real.

The prototype turns a scary "can I interview you" moment into a casual "check this out" moment. That is the whole trick.

Your Mom Test follow-up questions

The Mom Test is a framework for asking questions that reveal real behavior instead of collecting polite lies. The core principle: ask about concrete past behavior instead of opinions about the future.

After they see the generated quest, ask 2-3 of these questions:

  • "What did you actually do last evening after work?" This reveals whether they struggle to get out or are already exploring.
  • "When you have free time here, what usually happens?" This reveals their default behavior when nobody is pushing them.
  • "Have you tried anything to push yourself to explore more?" This reveals if they have actively tried to solve the problem before.
  • "What would make you actually do this quest right now?" This reveals barriers between interest and action.

Questions that get polite lies

Do NOT ask: "Would you use an app like this?" or "Would you pay for this?" These questions get polite lies every time. People say yes to be nice, then never follow through.

Stick to questions about what they have already done. Past behavior is the only reliable predictor of future behavior.

Why these specific questions work

Each question targets a different layer of validation. The evening question tells you if the problem exists. The free-time question tells you how they currently cope. The "tried anything" question tells you how painful the problem is. The barrier question tells you what your product needs to overcome.

What to record after each conversation

Write these down immediately after each conversation. Memory fades fast, and the specific details matter more than your summary of them.

  • Their actual evening/free-time behavior. Scrolling? Netflix? Going out? Be specific about what they said.
  • Whether they have tried to solve the "getting out" problem before. If yes, what did they try? If no, why not?
  • Their genuine reaction to the generated quest. Excited? Meh? Confused? Did they laugh? Did they say "I'd actually do this"?
  • Any specific words they used to describe their situation. Their language is gold for your badge answers and future product copy.

Use your phone's notes app

Open your notes app before each conversation with the four bullet headings pre-typed. After the person walks away, fill in the details while they are fresh. Even a 30-second voice memo works if typing feels too slow.

How long should each conversation be?

Keep it to 5-10 minutes total. The 30-second demo plus 2-3 follow-up questions is the sweet spot for guerrilla user research. Any longer and you are taking too much of their time at a coworking space.

Your interview playbook is ready. Next up, you will head to the Lounge, run your conversations, and turn the notes into badge-ready answers.

Run Your Interviews and Complete Your Badge

Your interview playbook is ready and your prototype is live on your phone. Now comes the part that turns a side project into a real product: talking to actual people.

In this step, you will run 3+ conversations at the Lounge using your quest generator as an icebreaker. Then you will synthesize what you hear into your AI Squads Problem Spark badge submission.

In this step, get ready to:
  • Conduct 3+ guerrilla interviews at the Lounge coworking space.
  • Record structured notes from each conversation.
  • Write and submit your AI Squads Problem Spark badge answers.
Conduct your interviews at the Lounge

The prototype on your phone removes the biggest barrier to guerrilla user research: you are showing something, not pitching something. People are far more willing to react to a thing than answer hypothetical questions.

  • Start with your AI Squads course mates from the helpbank post. These are the easiest first conversations because they already know you.
  • After 1-2 warm-up conversations, approach 2-3 other people at the Lounge who look like they are between tasks.
  • Use your opening line: "Hey, I am testing something I built. It takes 30 seconds. Can you tell me your mood and how much free time you have?"
  • Pull up the app on your phone, input their answers, and show them the generated quest. Watch their face.
  • After they react, ask 2-3 of your Mom Test follow-up questions from your playbook.

Keep each conversation to 5-10 minutes

You only need 2-3 focused follow-up questions per person. The prototype demo takes 30 seconds. The whole interaction should feel casual, not like a formal interview.

Immediately after each conversation, write down your notes. Do not wait until the end of the day.

  • Record their actual evening/free-time behavior (scrolling? Netflix? going out?).
  • Record whether they have tried to solve the "getting out" problem before.
  • Record their genuine reaction to the generated quest (excited? meh? confused?).
  • Record any specific words they used to describe their situation.

Why record their exact words?

Your badge answers are strongest when you write the problem statement in your interviewees' language, not your own. Their words carry authenticity that paraphrasing loses.

If someone says "I just end up doom-scrolling because I can't decide what to do," that phrase is gold for your Problem Statement answer.

Feeling nervous about approaching people?

Remember: you are not asking for anything. You are showing them something fun you built. Most people at coworking spaces are happy to give 30 seconds of reaction. The prototype is your social proof.

If someone says no, smile and move on. You only need 3 conversations total.

How can I make guerrilla user research less awkward at a coworking space?

Write your badge answers and submit

With 3+ conversations behind you, it is time to synthesize your notes into your AI Squads Problem Spark badge. Each question maps directly to what you just experienced.

Question 1: Your goal
  • Answer: "Make money." You are building a real business, not a hobby project.
Question 2: Problem statement

Write this in the words your interviewees actually used. Pull directly from your notes.

  • Structure it as: who has the problem, what the problem is, and why it persists.
  • Example shape: "Solo travelers and digital nomads have all the freedom in the world but default to scrolling and Netflix because exploring alone feels daunting, there are too many options, and nobody is pushing them out the door."
  • Replace the specific phrases with whatever language your interviewees actually used.
Question 3: Talk to potential users
  • Summarize what you learned from each conversation.
  • Focus on what they actually do with their free time, not what they say they want to do.
  • Include whether the "stuck scrolling" problem resonated with them.
  • Include their genuine reaction to the prototype (what they said, what their face did).

What makes a strong Q3 answer?

The best Q3 answers contrast what people say they want with what they actually do. "Person 2 said they love exploring but admitted they spent last evening watching Netflix in their room" is more convincing than "Person 2 said they would use my app."

Question 4: One-sentence product pitch
  • Write one sentence that captures what your app does and for whom.
  • Example: "A mobile app that gives solo travelers and digital nomads AI-generated real-world sidequests based on their mood, time, and location, turning exploration into a game."
  • Refine this based on what resonated most in your interviews.
Question 5: Explain your app
  • Write 2-4 sentences covering your most important feature (contextual quest generation from a fun AI buddy).
  • Include your 5-week MVP scope: single-player quest loop where users pick a mood, get a quest, complete it, earn XP, and level up their character.

Ground your answers in real data

Every answer is stronger when you reference something specific from your interviews. "3 out of 3 people I spoke to admitted they spent their last free evening in their room" hits harder than "nomads struggle to explore."

  • Review all 5 answers one more time to make sure they reference your actual interview data.
  • Submit your Problem Spark badge.

You now have a working prototype AND real user data backing up your product direction. That combination is rare at this stage. Next up, you can push further by adding persistent quest storage to track what your AI generates over time.

Secret mission

Add Quest History Storage

Right now, every quest vanishes the moment you generate a new one. Add persistent storage so each quest is saved to a Supabase table. This gives you real product data to analyze and a visible history your interviewees can scroll through.

Clean Up Your Resources

Clean Up Your Resources

Decide whether to keep your resources running, pause them to come back later, or delete them entirely. Your deployed app uses Claude API credits each time someone generates a quest, so leaving it published means anyone with the URL can trigger API calls on your account.

Cost warning

Every quest generation costs approximately $0.01 in Claude API credits. If your app stays published and someone uses it, you will be charged. Unpublish or delete the project if you want to stop all API usage.

Resources you used:

  • Lovable project sidekick-quest-gen (deployed app, Edge Function, Supabase database).
  • Lovable Cloud secret ANTHROPIC_API_KEY (stored server-side).
  • Claude API key on the Anthropic Console (the key itself, separate from Lovable).
  • Supabase quests table with generated quest data.

Keep everything running

No action needed. Choose this if you are still actively building your Sidekick MVP or plan to keep showing the prototype to potential users.

  • Your app stays live at its published URL.
  • Each quest generation uses approximately $0.01 in Claude API credits from your Anthropic account.
  • Your Lovable Pro subscription continues as normal.
  • The quests table continues accumulating data as quests are generated.

Pause - I'll come back to this later

Shut down public access to stop API charges while keeping your project intact for later.

  • Open your sidekick-quest-gen project in Lovable.
  • Click Publish, then click Unpublish.

This makes the live URL inaccessible. No one can trigger quest generation while the app is unpublished, so no API charges will occur. Your project remains in the editor for future work.

When you are ready to resume, publish the project again from the Lovable editor.

Delete - I don't want to use this again

Remove all project resources permanently. This cannot be undone.

  • Open your sidekick-quest-gen project in Lovable.
  • Go to Project Settings, then scroll down to Danger Zone.
  • Click Delete Project and confirm the deletion.

This permanently removes the project, the Edge Function, the ANTHROPIC_API_KEY secret, the quests table, and the deployed URL.

To revoke the Claude API key itself, sign in to the Anthropic Console and navigate to your API keys in account settings. Locate the key you created for this project and disable or delete it there.

Why delete the API key separately?

Deleting the Lovable project removes the secret from Lovable Cloud, but the key still exists on your Anthropic account. If you no longer need it, revoking it in the Anthropic Console prevents any future use.

Nice Work!

Nice Work!

You just built a real AI product and put it in front of real people. That is more validation than most founders get in a month of planning.

You've learned how to:

  • Build a working AI-powered quest generator in Lovable with Claude API integration via a secure Edge Function.
  • Design and iterate on a system prompt that gives Sidekick a distinct, fun buddy personality.
  • Conduct 3+ guerrilla user interviews using Mom Test techniques and submit your AI Squads Problem Spark badge.
  • Secret Mission: Added persistent quest storage in Supabase, giving you data for product decisions in your full MVP build.

Ready to quiz yourself?