Forem: Khôi Nguyễn Vũ

Code, AI, and Family: How I Used Google Gemini to Build for the People I Love

Khôi Nguyễn Vũ — Tue, 03 Mar 2026 10:25:27 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

What I Built with Google Gemini

My journey with Google Gemini has been all about two awesome projects: one that fixed a huge, exhausting headache for someone I love, and another that I'm working on right now to solve a real-world, everyday problem for my family! Both of these projects really showed me how AI is becoming way more than just a fun chat box to play with-it's a serious, incredibly powerful tool for building cool things that actually change how people work.

Project 1: The Meeting Transcribe App
Project 2: IoT Voice Calculator
What I Learned
Feedback & Conclusion

Project 1: The Meeting Transcribe App (Completed)

I built a long-audio transcription app to help out my girlfriend. She works in market research and spends hours upon hours interviewing people. Sometimes a single deep-dive session can last for 2 to 3 hours straight! To make her research reports rock-solid and trustworthy, she really needs accurate transcripts. If you have ever tried to manually type out a 3-hour conversation, you know it can easily take 9 or 10 hours of pausing, rewinding, and typing.

The catch? Real people don't talk like news anchors. They naturally speak with heavy local accents, use everyday slang, drop subjects from their sentences, and definitely don't speak in perfect grammar. We tried popular tools like YouTube auto-subs, Fireflies AI, and Whisper. They're totally great for English, but they really struggled to make sense of natural, fast-paced conversational Vietnamese. Paying for premium transcription services was super expensive, and honestly, it only gave us about 80-90% accuracy. That meant she still had to spend hours staring at a screen, fixing silly mistakes.

So, using Google AI Studio, I built a custom React app specifically tailored for her. I initially hosted it on Google Cloud Run, but paying for a production API key for a custom personal project started to add up way too fast. My workaround? I just shared the AI Studio project directly with her and taught her how to run it "locally" on her own account using the generous free tier! It was incredibly empowering to show a non-developer how to interact directly with the AI environment. It still processes everything beautifully. The result? An amazing ~95% accuracy for Vietnamese! It turns a messy, rough draft into a nearly finished transcript, saving her so much time and mental energy. Her research project is done now, but she will definitely use this setup for future projects whenever the need pops up. Moving forward, if her teammates ever need it, I’ll redeploy the app to Google Cloud Run to turn it into a proper production project.

Project 2: IoT Voice Calculator for Vietnamese Grocery Stores (Brainstorming/Next Steps)

For my next project, I'm using Gemini 3.0 to mix software with hardware, and it is actually designed for my mom! She runs a small, traditional grocery store (called a tạp hóa) in our hometown in a normal province in Vietnam (not a massive, tech-heavy city like Ha Noi or Ho Chi Minh).

For low-tech folks like my mom, the idea of setting up complex supermarket barcode scanners, inventory databases, and point-of-sale cash registers is way too complicated. It just adds too much workload to her day. A typical tạp hóa is super chaotic: motorbikes honking right outside, fans spinning loudly in the heat, and a bunch of customers pointing and yelling out their orders all at once. In that kind of environment, most of the time she just does mental math. If a customer buys a ton of stuff, she scrambles to write it all down on a scrap of paper to calculate it by hand while bagging the items. That's exactly how most small sellers operate in our hometown, and it is super stressful!

I'm designing a tiny, battery-powered device using an ESP32 microcontroller to fix this. The idea is simple: she doesn't have to touch anything. She just speaks naturally while working, like, "Hai chai nước tương, một ký đường" (Two bottles of soy sauce, one kilo of sugar). The device acts as an ear, sending the audio straight to my server, and Gemini acts as the brain. It understands the spoken Vietnamese, matches the colloquial item names to her store's database, and calculates the exact total in a flash! I'm also building a backend dashboard, but it's purely for me to manage things from afar. I'll use it to onboard new devices, instantly lock a device if it ever gets robbed, check how often she is using it, and manually add new local slang so the AI gets smarter over time. If it works well for her and makes her days easier, I'm going to let other local sellers in the neighborhood try it out too!

Demo

Check out the Transcribe App Prompt

What I Learned

Building the Transcribe app and mapping out the IoT device taught me some really valuable, hard-earned lessons:

Designing for Real People: I learned that high-tech solutions (like those fancy barcode scanners) completely fail if they don't match the user's actual tech level. Building an app for my mom means the UI has to be completely invisible. Buttons are intimidating; voice is natural. She shouldn't have to learn a new operating system or change how she works; she just needs to talk out loud and get the correct answer back.
The Challenge of Local Dialects: Vietnamese isn't just one standard sound—we have so many incredibly distinct regional accents from the North, Central, and South! Because Vietnamese isn't as globally dominant as English in AI training data, I realized that teaching the AI to perfectly recognize voice and calculate money across different local provinces will take time, patience, and constant tweaking with local slang. It is a long-term learning process for both me and the model.
Handling Large Files: I learned the right way to deal with huge files using the Gemini File API flow. At first, I thought about passing the audio as Base64 strings directly in the JSON payload. I quickly realized that a 3-hour audio file can easily be hundreds of megabytes, and sending that much data at once is a fast way to crash a browser or instantly time out a server! Staging it securely through the File API made the app infinitely more stable and scalable.
Keeping it Simple: I realized that getting perfect, down-to-the-millisecond timestamps is super hard when people talk passionately over each other. But I learned that my girlfriend's market research cares way more about what was said, not the exact millisecond it happened. Accepting "approximate time" (like grouping text into 30-second blocks) saved me a massive ton of engineering headaches while still being exactly what she needed for her reports!

Google Gemini Feedback

What went great:

I used Gemini 3.0 Pro to architect and build the code, and Gemini 3.0 Flash to rapidly process the heavy audio. The massive context window and the generous free tier in Google AI Studio made this entire journey possible for a solo developer like me. When my Cloud Run API costs got too high, being able to simply transition my girlfriend to use the AI Studio project locally on her own free-tier account was an absolute lifesaver! As the Google team keeps improving the Gemini API over time, I know this tool is only going to get faster and smarter for her future research.

The Vietnamese language support is honestly out of this world! It handles local phrases, dropped pronouns, and thick accents way better than other dedicated tools I've tried. Plus, having AI Studio auto-generate the starter React code let me focus my weekends purely on the fun API logic and architecture. The UI that Gemini generated right out of the box was so awesome and modern-I didn't even have to waste time tweaking CSS or fighting with buttons!

Where things got bumpy (The bad and the ugly):

It wasn't all smooth sailing, though! Pushing the limits of audio processing definitely led to some speed bumps:
Click to see the technical hurdles I faced

Cloud Run Proxy Headaches: Using a template backend on Cloud Run was great at first, but serverless architectures really hate long-running tasks. I ran into major timeout limits when handling those massive 3-hour audio uploads. I had to heavily tweak the backend to safely stream the files without dropping the connection before Gemini could even start its job.
Audio Hallucinations & Parallel Processing: Even with Gemini's huge context window, feeding a full 3-hour audio file straight into the model sometimes caused it to skip important parts or, hilariously, completely make up new conversations near the end of the file! My fix was to write a script that chops the massive audio file into smaller, bite-sized 10-20 minute pieces. I then process those smaller files in parallel to drastically increase the response time, and finally stitch the text back together perfectly at the end.
Talking Over Each Other: When multiple people get excited during an interview and talk at the exact same time, it is super hard to tell who is who. The model still gets a bit confused when voices completely blend together, which is a tough diarization problem I'm still looking to improve.

Despite the hiccups, the intense challenges I overcame building the Transcribe app gave me the exact confidence I need to start building my ESP32 grocery assistant. The spark has definitely been lit, and I can't wait to bring Gemini out of the browser and into the physical world to help out my mom!

A Huge Thank You!

Before I sign off, I just want to send a massive thank you to the Google AI team for building AI Studio and Gemini. Being a solo, personal developer, these tools have given me the superpower to actually build and ship real-world solutions that directly help the people I love around me.

Surprise! This entire blog post was actually written and refined using the new Gemini chat with Canvas tool! As a non-native English speaker, I'm amazed at how these tools helped me articulate my ideas. What do you think of the result? AI is such a powerful ally for developers worldwide, ensuring that language isn't a barrier to bringing our unique projects to the global stage.

Let me know your thoughts in the comments!

Copilot CLI as a Creative Engine: Building My TUI Trilogy

Khôi Nguyễn Vũ — Sun, 15 Feb 2026 19:06:41 +0000

This is a submission for the GitHub Copilot CLI Challenge

🚀 From Cyberpunk to Zen: A Trilogy of TUI Tools

For this challenge, I didn't just build one tool; I built a trilogy of Terminal User Interface (TUI) applications. My goal was to leverage GitHub Copilot to transform the cold command line into a living, breathing digital ecosystem.

The journey evolved from a rigid, agent-based approach to a fluid, context-engineered workflow. Here is the result of that evolution.

1. ⚡ The Netrunner Deck (Cyberpunk Monitor)

The "High-Friction" Experiment

My first project is a cyberpunk-themed network monitor. It visualizes Docker containers and network connections as a ASCII topology.

Matrix Rain effects on the side panels.
Deterministic Placement: Nodes use SHA-256 hashing so your infrastructure always looks the same.
Live Monitoring: Real-time Docker and network status updates.

2. 🌳 Code Bonsai (Git Visualizer)

The "Freestyle" Experiment

A digital terrarium that transforms your git repository into a growing ASCII bonsai tree:

Trunk: Thickness represents lines of code.
Leaves: Represent healthy files.
Weather: The "sky" changes based on commit activity (sunny for active days, moonlit for dormant ones).
Wildlife: "Bugs" appear on branches proportional to linting errors.

3. 🏠 Cozy Cabin (Terminal Wallpaper)

The "Context Engineering" Masterpiece

An interactive terminal background designed for focus and calm. It renders a "digital cabin window" with:

Procedural Scenery: Layered mountains and forests with live weather from OpenWeatherMap (clouds, rain, day/night cycles).
System Shelf: A unique take on system monitoring where:
- 🔋 Battery Cat: Naps when discharging, wakes up when plugged in.
- 🌿 RAM Plant: Wilts if memory usage gets too high.
- 🔥 CPU Fireplace: Flickers more intensely as your CPU load increases.

🏗️ Architecture & Workflow

The most interesting part of this challenge wasn't just the code, but how my interaction with Copilot changed. I moved from using pre-defined agents to a "Context Engineering" approach.

┌──────────────────────┐      ┌──────────────────────┐      ┌──────────────────────┐
│  Phase 1: Netrunner  │      │  Phase 2: Code Bonsai│      │  Phase 3: Cozy Cabin │
│  (Rigid Agents)      │      │  (Freestyle/Native)  │      │  (Context First)     │
└──────────┬───────────┘      └──────────┬───────────┘      └──────────┬───────────┘
           │                             │                             │
           ▼                             ▼                             ▼
   [Defined Persona]            [Raw Prompts + Models]        [Plan.md + Context]
           │                             │                             │
           ▼                             ▼                             ▼
    (Slow Iteration)             (Fast but Chaotic)           (Rapid & Reliable)
           │                             │                             │
           ▼                             ▼                             ▼
    "It works, but..."            "80% There"                 "90% Ready Code"

🧰 The Tech Stack

While my Copilot workflow changed, my core technology stack remained consistent across all three projects. This constant variable allowed me to truly measure the efficiency gains from my evolving AI strategies.

Language: Python 3.12+
TUI Framework: Textual (for the reactive interface)
Rendering: Rich (for beautiful terminal formatting)
Package Manager: uv (for lightning-fast dependency management)
APIs & Libraries: Docker SDK, psutil, OpenWeatherMap API

Demo

My Experience with GitHub Copilot CLI

My journey through these three projects wasn't just about building apps—it was an experiment in how to use AI effectively.

Phase 1: The "By the Book" Approach

Time Cost: 2 Days

When I started with The Netrunner Deck, I tried to follow every best practice perfectly. I set up the .github/ configuration and relied on predefined prompt templates.

Model Usage: I used Claude Opus 4.5 for both planning and coding.
The Bottleneck: It worked, but it was slow and consumed too many premium requests. I eventually had to switch to Sonnet to conserve resources. The overhead of managing the "agents" and setting up rigid context meant I spent more time configuring the AI than coding.

Phase 2: The "Freestyle" Approach

Time Cost: 1 Day

For Code Bonsai, I stripped everything back. I removed the .github/ configuration and just used the native Copilot CLI capabilities.

Model Usage: I used Sonnet for planning and Codex for implementation.
The Breakthrough: Drastically faster. The tool returned code that was about 80% of what I wanted. It was liberating, but sometimes missed architectural nuance.

Phase 3: The "Context Engineer" Approach

Time Cost: 1 Day

By Cozy Cabin, I found my "sweet spot." I kept the lightweight setup but focused on Plan Review and Context Engineering—manually curating exactly what context the CLI needed before asking it to generate code.

Model Usage: I used Codex exclusively, relying on my engineered context to guide it.
The Result: This was the peak experience. The output adapted to 90% of my expectations. By focusing on the plan rather than the persona, Copilot became a true extension of my thought process.

Conclusion: The "Greenfield" Flow

Based on this trilogy of experiments, here is my recommended workflow for starting a new project with Copilot CLI:

Plan with Power: Use high-reasoning models like Claude Opus or Gemini Pro to create the initial plan.
Review: Review the plan carefully. Note: The plan is saved in the chat session memory by default, not as a file in the repo, to keep the workspace clean.
Code with Speed: Switch to GPT Codex for implementation. It's faster and follows the context well.
Feedback Loop: Implement the code, check the layout/structure, and provide feedback.
Initialize Context: Use /init to generate project-specific Copilot instructions.
Optimized Instructions: Use the awesome-copilot plugin to find the best agent/instruction/prompt for your specific project type.
Iterate: Return to the planning step for the next feature. Crucial: Update the Copilot instructions frequently to keep the context fresh.
Leverage MCP: Use Model Context Protocol (MCP) tools like Context7 (to check best practices & modern frameworks) and Serena (to optimize context indexing).

The Copilot CLI isn't just a code generator; it's a collaboration engine. My key takeaway is that Plan > Config. A well-structured plan and curated context are far more effective than a heavily configured environment.

📚 References

Tools: GitHub Copilot CLI, Context7 (MCP), Serena (MCP)
Inspiration: awesome-copilot (for prompt engineering) copilot best practice
Libraries: Textualize

Algolia v5 + Algolia Agent Studio + Next.js 16: Building a Startup Validator

Khôi Nguyễn Vũ — Mon, 09 Feb 2026 05:52:16 +0000

This is a submission for the Algolia Agent Studio Challenge: Consumer-Facing Conversational Experiences

What I Built

Startup Roast is an AI-powered startup idea validator that provides brutally honest feedback by analyzing your idea against a database of 2,500+ real YC startups and 403+ failed companies.

Before you quit your job, raise money from friends and family, or spend months building something nobody wants - get a reality check in seconds, not months.

The Problem

Every year, thousands of entrepreneurs start companies based on "gut feelings" and encouragement from supportive friends who don't want to hurt their feelings. Meanwhile, there are decades of startup data available showing patterns of success and failure that nobody consults until it's too late.

The Solution

Startup Roast combines conversational AI with retrieval from thousands of real companies to provide:

Survival Probability Score - Multi-factor algorithm (Growth 35%, Market 25%, Team 20%, Funding 15%, Trend 5%)
Market Saturation Analysis - Know if you're entering a crowded space
Funding Likelihood - Realistic assessment based on similar companies
Graveyard Insights - See similar companies that failed and WHY they failed
Pivot Suggestions - Actionable alternatives when your concept needs refinement

The Experience

Search for any startup or describe your own idea
AI retrieves relevant context from 2,900+ companies using RAG
Get structured, visual feedback with actionable insights
Explore pivot suggestions with one click

Demo

Live URL: https://ai-roasting-algolia.vercel.app

Video Demo:

Repository: https://github.com/VuKhoiGVM/ai-roasting-algolia.git

How I Used Algolia Agent Studio

Data Indexed

I created two Algolia indices with rich, structured data:

1. Startups Index (2,500 records)

Data Structure:

{
  "objectID": "yc_31306",
  "name": "Martini",
  "description": "Collaborative AI-native filmmaking for professionals",
  "long_description": "Martini is a collaborative, AI-native platform...",
  "batch": "W26",
  "status": "Active",
  "tags": ["Generative AI", "Entertainment", "Design Tools"],
  "location": "San Francisco",
  "year_founded": 2025,
  "team_size": 2,
  "website": "https://martini.film",
  "is_hiring": false,
  "open_jobs": 0,
  "category": "Generative AI",
  "survival_score": 64,
  "survival_breakdown": {
    "total": 64,
    "growth": 14,
    "market": 100,
    "team": 100,
    "funding": 60,
    "trend": 100,
    "penalty": 0
  },
  "saturation": "Medium"
}

Searchable Attributes: name, description, long_description, category, sector, tags, batch, location

Custom Ranking: Higher survival_score → higher rank, then hiring companies get boost

Facets: category, status, sector, batch, is_hiring, saturation, year_founded

2. Graveyard Index (403 records)

Data Structure:

{
  "objectID": "fail_Health_Care_0",
  "name": "Aira Health",
  "sector": "Health Care",
  "category": "Health Care",
  "years_of_operation": "2015-2019",
  "what_they_did": "Personalized asthma/allergy app",
  "how_much_raised": "$12M",
  "raised_amount": 12000000,
  "why_they_failed": "Small user base and cash shortage",
  "takeaway": "Niche apps need big audiences",
  "year_founded": 2015,
  "year_closed": 2019,
  "lost_to_giants": true,
  "no_budget": true,
  "competition": true,
  "poor_market_fit": true
}

Searchable Attributes: name, what_they_did, why_they_failed, takeaway, category, sector

Custom Ranking: Higher raised_amount → higher rank (bigger failures are more educational), then more recent failures

Facets: 40+ failure reason flags (lost_to_giants, no_budget, competition, poor_market_fit, monetization_failure, etc.)

Index Configuration

I configured both indices with optimized settings:

Custom Ranking (primary - determines result order):

// Startups: Prioritize high-quality, active companies
customRanking: [
  'desc(survival_score)',  // 🔥 Primary signal: companies with higher survival potential
  'desc(is_hiring)',       // 📈 Active growth signal: hiring = expanding
  'desc(batch)',           // 🆕 Recency bias: newer batches first (W26 > W25)
  'asc(name)'              // 📝 Alphabetical tie-breaker for consistency
]

// Graveyard: Most educational failures first
customRanking: [
  'desc(raised_amount)',   // 💰 Raised more $$ = more expensive lesson = higher priority
  'desc(year_closed)',     // 📅 Recent failures = more relevant to current market
  'asc(name)'              // 📝 Alphabetical tie-breaker
]

Why This Ranking Works:

survival_score first ensures the best companies surface when browsing
is_hiring as boost rewards actively growing companies
batch recency gives newer YC companies visibility (they need it more!)
raised_amount for graveyard shows the most dramatic failures ($3.5B Faraday Future story > $50K failure)

Searchable Attributes (after ranking - determines which fields are searched):

searchableAttributes: [
  'name',           // Exact company name matches rank highest
  'description',    // Then description content
  'long_description',
  'category',       // Category matches
  'tags',           // Tag matches
  'batch',          // YC batch
  'location'
]

Typo Tolerance: Enabled for 4+ character words, 2 typos for 8+ character words

Frontend Integration

Algolia JavaScript SDK v5

Using Algolia JavaScript SDK v5.35.0 with the new search API:

import { algoliasearch } from 'algoliasearch'

// Initialize client with search-only key (safe for frontend)
const client = algoliasearch(
  process.env.NEXT_PUBLIC_ALGOLIA_APP_ID,
  process.env.NEXT_PUBLIC_ALGOLIA_SEARCH_KEY
)

// v5 Breaking Changes: initIndex() removed, use search() with requests array
const { results } = await client.search({
  requests: [
    {
      type: 'default',
      indexName: 'startups',
      query: 'AI healthcare',
      hitsPerPage: 20,
      filters: 'survival_score >= 40',  // Only good survival rates
      attributesToHighlight: ['name', 'description', 'category'],
      highlightPreTag: '<em>',
      highlightPostTag: '</em>',
    }
  ]
})

const hits = results[0].hits

Key Search Functions Implemented:

// 1. Unified Search - both indices in parallel
searchAll(query: string) → Promise<(Startup | FailedStartup)[]>

// 2. Single index search with filters
searchStartups(query, { category, hitsPerPage, filters, facetFilters })

// 3. Top performers
getTopStartups() → Top 10 by survival_score (filtered >= 40)
getTopGraveyardEntries() → Top 10 by raised_amount

// 4. Faceting for filters
getCategories() → Category names with counts
getBatchFacets() → YC batches with counts (sorted by recency)
getAllFacets() → All facets in parallel using Promise.all()

// 5. Category filtering
searchStartupsByCategory(category)
searchGraveyardByCategory(category)

Search Response with Highlights:

{
  "objectID": "yc_31306",
  "name": "Martini",
  "description": "Collaborative <em>AI</em>-native filmmaking...",
  "category": "Generative <em>AI</em>",
  "_highlightResult": {
    "name": { value: "Martini", matchLevel: "none" },
    "description": { value: "Collaborative <em>AI</em>-native...", matchLevel: "full" }
  }
}

Vercel AI SDK + Agent Studio

Using Vercel AI SDK v6 with direct Agent Studio transport (no backend needed!):

import { useChat, DefaultChatTransport } from "ai"

const transport = new DefaultChatTransport({
  api: `https://${appId}.algolia.net/agent-studio/1/agents/${agentId}/completions?compatibilityMode=ai-sdk-5`,
  headers: {
    "x-algolia-application-id": appId,
    "x-algolia-api-key": searchKey,  // Search-only key (safe for client)
  },
})

const chat = useChat({ transport })

// Send message
chat.sendMessage({ text: userInput })

Response Parsing:

// Extract metrics from structured AI response using regex
const survivalMatch = text.match(/\*\*Survival Probability:\*\*\s*(\d+)%?/i)
const saturationMatch = text.match(/\*\*Market Saturation:\*\*\s*(Low|Medium|High)/i)
const fundingMatch = text.match(/\*\*Funding Likelihood:\*\*\s*(\d+)%?/i)

// Parse graveyard entries
const graveyardMatch = text.match(/\*\*💀[^*]*:\*\*([\s\S]*?)(?=\*\*🔄|\*\*The Roast|$)/i)

// Parse pivot suggestions
const pivotMatch = text.match(/\*\*🔄[^*]*:\*\*([\s\S]*?)(?=\*\*|$)/i)

Rendering Components:

Survival probability → colored progress bar (green ≥70%, yellow 40-69%, red <40%)
Market saturation → visual meter with emoji indicators (🔥 Low, ⚠️ Medium, 🚫 High)
Funding likelihood → percentage meter with confidence level
Graveyard section → cards showing failed companies with reasons
Pivot suggestions → clickable chips that re-analyze the new direction

Real-time Search UI:

// Debounced search as user types
const [results, setResults] = useState([])

useEffect(() => {
  const timer = setTimeout(async () => {
    const hits = await searchAll(query)  // Searches both indices
    setResults(hits)
  }, 300)
  return () => clearTimeout(timer)
}, [query])

Query Rules

I implemented query rules for both indices to enhance search experience:

Startups Index Query Rules

AI/ML Category Boost:

// Searching "ai", "ml", "llm", "gpt" → Boost AI/ML companies to top
{
  condition: { pattern: 'ai', anchoring: 'contains' },
  consequence: {
    filterPromotes: true,
    params: {
      filters: 'category:Artificial Intelligence OR category:Machine Learning OR category:AI'
    }
  }
}

Dev Tools Category Boost:

// Searching "dev tools", "developer tools" → Boost Dev Tools companies to top
{
  condition: { pattern: 'dev', anchoring: 'contains' },
  consequence: {
    filterPromotes: true,
    params: {
      filters: 'category:Developer Tools'
    }
  }
}

Fintech Category Boost:

// Searching "fintech", "financial" → Boost Fintech companies to top
{
  condition: { pattern: 'fintech', anchoring: 'contains' },
  consequence: {
    filterPromotes: true,
    params: {
      filters: 'category:Fintech'
    }
  }
}

Graveyard Index Query Rules

// Only show graveyard companies relevant when search keywords are 'failed', 'bankrupt', 'shutdown'
  {
    enabled: true,
    conditions: [{
      pattern: 'failed',
      anchoring: 'contains'
    }],
    consequence: {
      filterPromotes: false,
      userData: { showGraveyardFirst: true }
    },
    description: 'Show graveyard for "failed" queries'
  },

Agent Configuration

In Algolia Agent Studio, I configured a custom agent:

Tools Configuration

Both indices enabled for retrieval:

startups index search - For successful company analysis
graveyard index search - For failure pattern analysis

LLM Selection

Google Gemini 2.5 Flash - Chosen for:

Fast response times (<10 seconds)
Strong reasoning capabilities
Good with structured output

System Prompt Engineering

You are Startup Roast - a brutally honest startup advisor. Analyze ideas against real data.

Your response MUST follow this exact format:

**Survival Probability:** X%
**Market Saturation:** [Low/Medium/High]
**Funding Likelihood:** X%

**💀 The Graveyard (similar failures):**
- [Company Name]: [brief failure reason]

**🔄 Pivot Suggestions:**
- [Specific pivot idea with reasoning]

**The Roast:**
[Brutally honest analysis with specific references to similar companies from the retrieved data.
Be direct but constructive. Reference actual companies when making comparisons.]

Key Prompt Techniques Used:

Structured output format - Enables frontend parsing for visual metrics
Specific section markers - **💀 The Graveyard:** for regex parsing
Retrieval grounding - "Reference actual companies from retrieved data"
Tone setting - "Brutally honest but constructive"

Why This Approach

Instead of building a custom RAG pipeline with vector search and prompt engineering, Algolia Agent Studio gave me:

Feature	Custom RAG Pipeline	Algolia Agent Studio
Infrastructure	Vector DB, embedding API, backend server	Zero infra needed
Setup Time	Days to weeks	Hours
Retrieval Speed	2-5 seconds	<100ms
Cost	Multiple API costs	Single platform
Maintenance	High	Low
Grounding	Manual prompt engineering	Built-in RAG

Why Fast Retrieval Matters

The Speed Expectation

In a conversational interface, users expect responses in seconds, not minutes. When someone types "Uber for dog walking," they want feedback now, not after 30 seconds of loading spinners.

What Would Happen with Slow Retrieval

Without Algolia's millisecond-level retrieval:

User abandonment - 53% of users abandon sites that take >3 seconds to load
Context window limits - Can't retrieve enough relevant examples with slow APIs
Cold starts - Every query needs new retrieval, no caching benefits
Cascading delays - Slow retrieval → slow LLM → slow generation → frustrated user

How Algolia's Speed Improves Experience

Metric	With Slow Search	With Algolia
First response time	5-10 seconds	<1 second
Relevant examples retrieved	5-10	20-50
Context quality	Sparse	Rich & diverse
User engagement	Drop off after 1 query	Continue exploring pivots

Real Example

When a user types "dating app with AI matching for people over 30":

Algolia retrieves instantly:

500+ dating/tech companies across both indices
Failed companies like Woo ($1.5M raised, lost to Tinder)
Market saturation: High (dominated by Match Group, Bumble)
Survival Probability: 20%

Structured Metrics Displayed:

Survival Probability: 20% (Danger zone 💀)
Funding Likelihood: 15% (Better bring cash 💸)
Market Saturation: High (Crowded market 👥)

Graveyard Section:

💀 Woo ($1.5M) - Dating app for professionals, lost to Tinder. The dating app market is dominated by giants.

The Roast (with real data):

"The dating app market is a brutal graveyard for new entrants. You're entering a 'High' saturation market dominated by Match Group (Tinder, Hinge, OKCupid) and Bumble, who have massive user bases and deep pockets for marketing. Your differentiation, 'AI suggestions for matching,' is a feature, not a unique product. Woo raised $1.5M and couldn't compete with Tinder."

Pivot Suggestions:

"Divorced Parents Dating App" → 40% survival score
"Travel Enthusiasts Over 30" → Medium saturation

After clicking a pivot:
The user clicks "Divorced Parents Dating App" and the AI instantly re-analyzes:

Survival Probability improves to 40%
Market Saturation drops to Medium
New pivot suggestions appear

This shows the full power: instant retrieval → brutal honesty → actionable pivots. Users can iterate 5-6 times in one session, each time getting specific feedback grounded in real company data.

Tech Stack

Frontend: Next.js 16.1.6 (App Router + Turbopack), React 19
AI: Algolia Agent Studio, Vercel AI SDK v6, Google Gemini 2.5 Flash
Search: Algolia JavaScript SDK v5.35.0
Styling: Tailwind CSS v4, shadcn/ui
Data: 2,500 YC startups + 403 failed companies

What's Next

Potential improvements I'd love to add:

[ ] User accounts to save favorite roasts
[ ] Export analysis as PDF
[ ] Industry trend visualization
[ ] Investor perspective mode
[ ] Co-founder matching based on complementary skills

Built with 🔥 for the Algolia Agent Studio Challenge 2026

Demo: https://youtu.be/TuSimU_864U | Live: https://ai-roasting-algolia.vercel.app

💬 Got questions? Drop them in the comments below!

I'm happy to discuss:

Algolia Agent Studio setup and configuration
Survival score algorithm tuning
Working with Algolia v5 SDK
Startup graveyard data sourcing
Or anything else about the project!

Forem: Khôi Nguyễn Vũ

Code, AI, and Family: How I Used Google Gemini to Build for the People I Love

What I Built with Google Gemini

Table of Contents

Project 1: The Meeting Transcribe App (Completed)

Project 2: IoT Voice Calculator for Vietnamese Grocery Stores (Brainstorming/Next Steps)

Demo

What I Learned

Google Gemini Feedback

What went great:

Where things got bumpy (The bad and the ugly):

A Huge Thank You!

Copilot CLI as a Creative Engine: Building My TUI Trilogy

🚀 From Cyberpunk to Zen: A Trilogy of TUI Tools

1. ⚡ The Netrunner Deck (Cyberpunk Monitor)

2. 🌳 Code Bonsai (Git Visualizer)

3. 🏠 Cozy Cabin (Terminal Wallpaper)

🏗️ Architecture & Workflow

🧰 The Tech Stack

Demo

My Experience with GitHub Copilot CLI

Phase 1: The "By the Book" Approach

Phase 2: The "Freestyle" Approach

Phase 3: The "Context Engineer" Approach

Conclusion: The "Greenfield" Flow

📚 References

Algolia v5 + Algolia Agent Studio + Next.js 16: Building a Startup Validator

What I Built

The Problem

The Solution

The Experience

Demo

How I Used Algolia Agent Studio

Data Indexed

1. Startups Index (2,500 records)

2. Graveyard Index (403 records)

Index Configuration

Frontend Integration

Algolia JavaScript SDK v5

Vercel AI SDK + Agent Studio

Query Rules

Startups Index Query Rules

Graveyard Index Query Rules

Agent Configuration

Tools Configuration

LLM Selection

System Prompt Engineering

Why This Approach

Why Fast Retrieval Matters

The Speed Expectation

What Would Happen with Slow Retrieval

How Algolia's Speed Improves Experience

Real Example

Tech Stack

What's Next