DEV Community: Paige Bailey

Vandalizing My Own Wikipedia Experience: A 90s Cyberpunk GeoCities Makeover

Paige Bailey — Fri, 20 Mar 2026 15:44:30 +0000

Wikipedia is a marvel. It is the Library of Alexandria of our time, a meticulously curated repository of human knowledge, wrapped in a user interface so ruthlessly utilitarian it makes a hospital corridor look like a rave.

But sometimes, when I am deep in a Wikipedia rabbit hole reading about List of animals with fraudulent diplomas at 2:00 AM, the sterile white background feels... insufficient. I don't want brutalist minimalism. I want the web the way the ancients intended: dripping in neon pink, plastered in Comic Sans, and crawling with pixelated cats.

So, I decided to write a custom Wikipedia User Script to turn the site into a 1998 GeoCities cyberpunk fever dream.

Instead of writing this from scratch, I wanted to see how well modern LLMs could handle writing niche MediaWiki API scripts. Here is a field report on how I built this abomination using Gemini 3.1 Pro Preview.

Grounding Gemini with Wikipedia-specific syntax

LLMs are great at writing vanilla JavaScript, but Wikipedia user scripts rely on specific, slightly archaic MediaWiki globals (like mw.loader.using and mw.util.addCSS). If you just blindly ask an LLM to "make Wikipedia pink," it usually hallucinates browser extensions or generic Tampermonkey scripts.

To bypass this, I jumped into Google AI Studio and loaded up the Gemini 3.1 Pro Preview model.

The secret sauce here was using the URL Context feature. I toggled URL Context on and pasted in the URL for Wikipedia's custom scripting documentation:
https://en.wikipedia.org/wiki/Wikipedia:User_scripts

My prompt was simple but unhinged:

"Using the provided documentation on Wikipedia User Scripts, write a script for my Special:MyPage/common.js that makes my Wikipedia viewing experience look like a 90s cyberpunk GeoCities page. I want a pink/cyan grid background, glowing Comic Sans headers, a massive scrolling <marquee> for the article title, a giant glowing sparkle mouse trail, and a squad of animated cats walking across the top of my screen."

Because Gemini 3.1 Pro Preview had the actual documentation in its context window, it knew exactly how to inject CSS securely via MediaWiki's utility functions, and it gave me a plug-and-play script.

Breaking down the script

The resulting script is a beautiful combination of modern DOM manipulation and deeply offensive 90s aesthetics.

1. The Marquee Title

If we are going to read about the Emu War, that title needs to move. The script grabs the #firstHeading element and violently wraps its inner HTML in a <marquee> tag.

var $title = $('#firstHeading');
var titleText = $title.html();
$title.html('<marquee scrollamount="15" behavior="alternate">' + titleText + '</marquee>');

Note: The fact that modern browsers in 2026 still parse and execute the <marquee> tag is a testament to the web’s unbreakable backwards compatibility. It is the digital equivalent of a vestigial tail.

2. The Sparkle Trail (A Lesson in Throttling)

To create the mouse trail, the script listens to the mousemove event and appends absolutely-positioned <span> elements containing cyberpunk symbols (✦, ★, ✨) to the DOM.

To prevent this from immediately melting my GPU (a very real threat when generating hundreds of DOM nodes a second), the model smartly implemented a timestamp throttle:

var now = Date.now();
if (now - lastSparkleTime < 40) return; // Only spawn a sparkle every 40ms
lastSparkleTime = now;

It then applies a CSS @keyframes animation to each sparkle so they slowly drift downward, rotate 180 degrees, and fade to opacity: 0 before being garbage-collected by a setTimeout a second later.

3. The Mathematics of Walking Cats

Instead of using a clunky JS setInterval to move the cats, Gemini 3.1 leaned into pure, hardware-accelerated CSS animations.

It created a fixed header container (pointer-events: none so I can still click the search bar through the cats' ethereal bodies). Then, it applied two separate animations.

The first animation slides the whole squad from 100vw (off-screen right) to -100% (off-screen left).

The second animation creates the "walking" illusion. If you think about the geometry of a walking pixel cat, it's essentially a sine wave. To achieve this, the script applies a 10px vertical bounce to each cat (transform: translateY(-10px)).

To make it look like a chaotic squad rather than a synchronized military parade, the script uses the nth-child(even) pseudo-class to offset the animation delay of every other cat:

.walking-cat {
    animation: catBounce 0.4s alternate infinite ease-in-out;
}
.walking-cat:nth-child(even) {
    animation-delay: 0.2s; /* Phase offset for the bounce! */
}

We are essentially phase-shifting the vertical oscillation of our felines to simulate independent locomotion.

The final results

I pasted the code into my Special:MyPage/common.js, hit publish, and bypassed my cache.

The result is staggering.

I am currently reading the deeply serious, heavily cited Wikipedia article for Maximilien Robespierre. The background is a dark void overlaid with a neon pink laser grid. The header "MAXIMILIEN ROBESPIERRE" is glowing in hot pink Comic Sans, aggressively bouncing off the edges of my monitor.

// Detect dark theme var iframe = document.getElementById('tweet-2035009322531660256-82'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2035009322531660256&theme=dark" }

Every time I move my mouse to hover over a citation, a massive explosion of 45-pixel-wide cyan stars erupts across the text. And above it all, a squad of five neon cats marches endlessly toward the left side of my screen, oblivious to the Reign of Terror occurring in the text below them.

It is awful. I am never turning it off.

If you want to ruin your own Wikipedia experience, you can find the complete script in the replies below. Just remember to log in, navigate to Special:MyPage/common.js and Special:MyPage/common.css, and let the 90s flow through you.

🦖 Image Manipulation on a Budget: Bounding Boxes and Transparency with Gemini 3.0 Flash and NanoBanana Pro

Paige Bailey — Wed, 04 Feb 2026 02:04:25 +0000

Hey friends! 👋

Let’s talk about something that used to be a total headache: Computer Vision pipelines. Usually, if you wanted to generate an asset, remove a background, and then detect specific objects with bounding boxes, you were looking at a complex stack. You’d need a generation model, a separate segmentation model (like SAM), and maybe some custom OpenCV scripts you had to write yourself.

But the game has changed!

I recently played around with NanoBanana Pro and the new Gemini 3.0 Flash with High thinking Code Execution enabled, and my jaw hit the floor. We are talking about an end-to-end workflow that generates, processes, and analyzes images using a sandboxed Python environment... all for fractions of a penny. You can test it out today for free in Google AI Studio.

Let’s dive into how we can turn a T-Rex and some LEGO bricks into production-ready assets without writing a single line of image processing code ourselves.

Tech Stack

Here is the dynamic duo (plus one) we are using today:

NanoBanana Pro: To generate our initial complex images with clean backgrounds.
Gemini 3.0 Flash: The speedster of the Gemini family, with High Thinking enabled. But you can also experiment with lower thinking settings!
Code Execution: This is the killer feature. Gemini doesn't just "guess" where the pixels are; it writes and runs Python code in a secure sandbox to manipulate the image mathematically.

Use Case 1: The Transparent T-Rex 🕶️🦖

First, I used NanoBanana Pro to conjure up a "Dinosaur with sunglasses on a white background.", based on an initial input image. It did a great job, but for web design, we usually need a transparent PNG, not a white JPEG.

Instead of opening Photoshop, I just asked Gemini 3.0 Flash to handle it.

The Prompt:

"Remove the background from this image, only show the dinosaur wearing sunglasses on a white background and nothing else - no pole, no grass, etc."

The Model's "Thinking" Process 🧠

One of the coolest things about the new high-thinking capability is watching the model plan. It literally told me:

"I'm focused on extracting the T-Rex skeleton..."
"I'm now zeroing in on a pristine white background."

The Execution 💻

Gemini didn't hallucinate the transparency. It wrote this Python script using OpenCV (cv2) and executed it:

import cv2
import numpy as np

# Load the image
image = cv2.imread('input_file_2.jpeg')

# Convert to grayscale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Threshold to get white background mask (background is 255)
# Using a threshold slightly below 255 to catch near-white pixels
_, mask = cv2.threshold(gray, 250, 255, cv2.THRESH_BINARY_INV)

# Convert to BGRA
bgra = cv2.cvtColor(image, cv2.COLOR_BGR2BGRA)

# Set alpha channel to 0 where mask is 0 (the white background)
bgra[:, :, 3] = mask

# Save the transparent PNG
output_path = 'dinosaur_transparent.png'
cv2.imwrite(output_path, bgra)

Boom! 💥 A perfectly cut-out T-Rex with zero background artifacts.

Use Case 2: Object Detection (The LEGO Test) 🧱

Next, let’s get a bit more technical. I uploaded an image of colorful LEGO bricks and wanted to identify only the green ones and draw bounding boxes around them.

The Prompt:

"Draw bounding boxes around the green LEGO bricks. Display the image with bounding boxes."

The Logic 🧠

Gemini identified that color segmentation was the best path here. It analyzed the image, determined the HSV range for that specific shade of "LEGO lime green," and wrote the following logic:

import cv2
import numpy as np
from PIL import Image

# Load the image
image = cv2.imread('input_file_4.png')
image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# Convert to HSV for better color segmentation
hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)

# Define range for green color in HSV
# Looking at the image, it's a lime green
lower_green = np.array([35, 50, 50])
upper_green = np.array([85, 255, 255])

# Create a mask for green
mask = cv2.inRange(hsv, lower_green, upper_green)

# Find contours in the mask
contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

# Create a copy of the image to draw on
output_image = image_rgb.copy()

# Filter contours by area and draw bounding boxes
for cnt in contours:
    area = cv2.contourArea(cnt)
    if area > 1000:  # Adjust threshold as needed
        x, y, w, h = cv2.boundingRect(cnt)
        # Blue bounding boxes for visibility on green
        cv2.rectangle(output_image, (x, y), (x + w, y + h), (255, 0, 0), 5) 

# Save and display the result
output_pil = Image.fromarray(output_image)
output_pil.save('green_bricks_detected.png')

It automatically calculated the contours, filtered out noise (area < 1000), and drew the boxes.

The Cost? 💸

This is the wildest part. Running this entire object detection workflow on the LEGO image cost approximately $0.006. That is six-tenths of a penny for intelligent computer vision code generation and execution.

Use Case 3: Transparency 🏁

Finally, I asked it to clean up the LEGO image just like the dinosaur—removing the white background to create a sprite-ready PNG.

Gemini pivoted strategies. It saw the background was pure white (255), so it utilized a high threshold approach for perfectly clean edges:

# Use threshold to find the white background
_, mask = cv2.threshold(gray, 250, 255, cv2.THRESH_BINARY_INV)

# Set the alpha channel based on the mask
bgra[:, :, 3] = mask

The result? A clean transparent asset ready for your next project.

Why this matters 💡

We are moving away from "Prompts that guess" to "Prompts that do."

By combining Gemini 3.0 Flash's High Thinking (to plan the approach) with Code Execution (to actually do the math using Python libraries like NumPy and OpenCV), we get results that are:

Deterministic: The code runs the same way every time.
Verifiable: You can see exactly how the model solved the problem.
Incredibly Cheap: We are leveraging efficient models to write code, rather than using massive vision models to brute-force pixel generation.

Have you tried Code Execution with Gemini yet? If you're building automated asset pipelines, this is a total game changer!

Check out the docs here: Gemini API Code Execution

Happy coding! 👩‍💻✨

Benchmarking on a Budget: Running massive evals for 50% less with the Gemini Batch API ⚡️

Paige Bailey — Mon, 26 Jan 2026 05:09:53 +0000

Hey developers! 👋

Running evaluations on LLMs can be a bit of a headache. You hit rate limits, you stare at loading bars, and -- probably worst of all -- you burn through your API budget faster than a GPU on a training run. But what if I told you there’s a way to run thousands of prompts asynchronously, at 50% of the cost, without blocking your main thread?

Enter the Gemini Batch API.

Today, we are going to take a classic coding benchmark from Hugging Face -- the OpenAI HumanEval dataset -- and run it through Google’s small, lightweight gemini-2.5-flash-lite model using the Batch API. Then, we’re going to evaluate the code it generates and visualize the results.

Grab your coffee (or tea 🍵), and let’s dive in!

The stack

Here's what we'll be building with today:

Google Gen AI SDK: To talk to Gemini.
HuggingFace Datasets: To get our evals.
Pandas and Seaborn: To make the data look pretty.
Python exec: To (carefully!) run the generated code.

Step 1: Preparing the Data

First things first, we need our prompts. We are using the openai_humaneval dataset, which contains 164 coding problems.

The Batch API loves JSONL (JSON Lines) files. Each line is a separate request. We need to iterate through the dataset and format it so Gemini understands that we want it to write Python code.

import json
from datasets import load_dataset

# Load the test split
ds = load_dataset("openai/openai_humaneval", split="test")

jsonl_filename = "humaneval_input.jsonl"
print(f"Generating {jsonl_filename}...")

with open(jsonl_filename, "w") as f:
    for item in ds:
        # Sanitize the ID
        custom_id = item["task_id"].replace("/", "_")

        # Prompt Engineering: Be specific!
        prompt_text = (
            f"Complete the following Python function. "
            f"Provide ONLY the code, no explanation.\n\n{item['prompt']}"
        )

        # Construct the request object
        entry = {
            "custom_id": custom_id,
            "method": "generateContent",
            "request": {
                "contents": [{"role": "user", "parts": [{"text": prompt_text}]}],
                "generation_config": {"temperature": 1.0}
            }
        }
        f.write(json.dumps(entry) + "\n")

Pro Tip: Notice custom_id? That’s your best friend. Since batch jobs are asynchronous, results might not come back in the same order you sent them. The ID helps you map the answer back to the question.

Step 2: Upload the data to Google Cloud

Now that we have our humaneval_input.jsonl, we need to upload it to Google's Cloud Platform and tell Gemini to get to work. We are using gemini-2.5-flash-lite here because it is fast, efficient, and perfect for high-volume tasks like this - but you could use any supported Gemini model docstring instead.

from google import genai
from google.genai import types

client = genai.Client(api_key="YOUR_API_KEY")

# 1. Upload the file
print("Uploading file to Gemini API...")
uploaded_file = client.files.upload(
    file=jsonl_filename,
    config={'mime_type': 'application/jsonl'}
)

# 2. Kick off the Batch Job
print("Submitting batch job...")
batch_job = client.batches.create(
    model="gemini-2.5-flash-lite",
    src=uploaded_file.name,
    config=types.CreateBatchJobConfig(display_name="humaneval_batch_job")
)

print(f"Batch Job Created: {batch_job.name}")
print(f"Current Status: {batch_job.state}")

And now... we wait. ⏳

Batch jobs aren't instant (that's the trade-off for the discount), but for an evaluation pipeline, it's perfect. Go stretch, grab a snack, or check Twitter. On average, my jobs for the HumanEval dataset have been taking ~10 minutes, and the majority complete in less than a few hours.

Step 3: Downloading the results

Once the job hits JOB_STATE_SUCCEEDED, the results are ready to come home.

# Check status (you'd likely loop this in production)
job = client.batches.get(name=batch_job.name)

if job.state.name == 'JOB_STATE_SUCCEEDED':
    remote_filename = job.dest.file_name
    print(f"Downloading results from: {remote_filename}")

    # Save the output locally
    content_bytes = client.files.download(file=remote_filename)

    with open("results.jsonl", "wb") as f:
        f.write(content_bytes)

    print("✅ Results saved locally!")

Step 4: Evaluations

This is where the magic happens. We have the code Gemini wrote; now we need to see if it actually works. We’re going to loop through our results, extract the Python code (removing those pesky markdown backticks), and run it against the unit tests provided in the HumanEval dataset.

⚠️ Warning: We are using exec() here. In a production app, running untrusted code is a huge security no-no. But for a local sandbox evaluation, we live on the edge! We’ll wrap it in a signal timeout so infinite loops don’t freeze our machine.

import signal

# Safety timeout handler
class TimeoutException(Exception): pass
def timeout_handler(signum, frame): raise TimeoutException()
signal.signal(signal.SIGALRM, timeout_handler)

results_map = {}
# ... (Load results into results_map dictionary) ...

passed = 0
total = len(ds)

print("Starting Evaluation with Timeouts...\n")

for item in ds:
    cid = item["task_id"].replace("/", "_")
    generated_code = results_map.get(cid, "")

    # Combine prompt + generated code + test case
    test_script = f"{item['prompt']}\n{generated_code}\n\n{item['test']}\ncheck({item['entry_point']})"

    try:
        signal.alarm(2) # 2-second timeout per problem
        exec_globals = {}
        exec(test_script, exec_globals)
        signal.alarm(0) # Disable alarm
        passed += 1
        print(f"✅ {item['task_id']}: Passed")
    except Exception as e:
        signal.alarm(0)
        print(f"❌ {item['task_id']}: FAILED ({type(e).__name__})")

Step 5: The results!

So, how did gemini-2.5-flash-lite do? Let's visualize it using Seaborn.

import matplotlib.pyplot as plt
import seaborn as sns
import pandas as pd

# ... (Create DataFrame from results) ...

plt.figure(figsize=(10, 6))
sns.set_theme(style="whitegrid")
colors = {"Passed": "#2ca02c", "Failed": "#d62728", "Error": "#ff7f0e", "No Code": "#7f7f7f"}

ax = sns.countplot(y="status", data=df, hue="status", palette=colors, order=df['status'].value_counts().index)
plt.title("HumanEval Evaluation Results", fontsize=16)
plt.show()

🥁 Drumroll please...

Passed: 142 tasks (86.59%)
Failed: 8 tasks
Errors: 9 tasks

86.59% Pass Rate! 🤯

That is incredibly impressive for a "Flash-Lite" model. It handled complex algorithmic logic, string manipulation, and math problems, passing the vast majority of them.

Final thoughts

The Gemini Batch API is a game-changer for workflows like this.

Cost: We saved 50% on tokens.
Scale: We didn't have to manage async loops or retry logic.
Performance: The Gemini 2.5 Flash-Lite model punched way above its weight class.

If you have large datasets, extensive prompting jobs, or nightly evaluations, definitely give the Batch API a spin. And if you'd like to see the full code, check out this Colab notebook.

Happy building! ✨

References:

Building a Neon-Soaked Last.fm Roast Bot for $1.75/Year

Paige Bailey — Thu, 15 Jan 2026 22:04:37 +0000

We all have that one song in our listening history that we hope nobody sees. But instead of hiding my shame, I decided to automate it!

I recently built my own custom AI bot on Poe called lastfm-roaster. Its only job is to look at a person's Last.fm music taste (if you're curious. here's mine as an example) and absolutely destroy them.

But there was a problem: The roasts were trapped in the chatbot interface. I wanted them delivered straight to my inbox every morning so I could easily forward the best (worst) burns to my friends for a laugh.

So, I built a pipeline.

Today, I’m going to show you how I connected my custom Poe bot to a Python script that pings the API, analyzes my listening history, and uses Regex to inject random neon colors into a beautiful HTML email.

Best of all? It runs entirely for free on GitHub Actions, and the API costs less than a cup of coffee for the entire year.

Onward!

Building the Bot 🤖

I went to Poe and created a new bot using their ScriptBot feature. I gave it a specific system prompt roughly like this:

"You are a pretentious music critic. Your job is to analyze Last.fm profiles and roast them mercilessly. Be sarcastic, use slang, and do not hold back."

After iterating back and forth with the ScriptBot until I was satisfied with the results, I had the intelligence (lastfm-roaster), but I needed to get the output out of Poe and into my email.

Keys and Secrets 🗝️

We are going to use GitHub Actions to run this, which means we need to keep our API keys safe. Never hardcode passwords in your script!

1. Get the Keys

Poe API Key: Go to poe.com/api_key and grab your key.
Gmail App Password: To send email via Python, you can't use your normal password. Go to your Google Account > Security > 2-Step Verification > App Passwords. Generate one and save that 16-character code.

2. Store them in GitHub

Create a new private repository on GitHub, then go to Settings > Secrets and variables > Actions.

Add these three secrets:

POE_API_KEY
EMAIL_ADDRESS
EMAIL_PASSWORD

Step 3: The Code 🐍

We need a few Python libraries to make this magic happen. Create a file named requirements.txt in your repo:

openai
markdown

(Yes, we use openai! Poe's API is now compatible with the OpenAI client, making it super easy to use. Gemini 2.5 Flash is referenced via the Poe API, so I don't have to worry about managing that key, as well.)

The "Neon" Script (`lastfm_roast.py`)

Here is the cool part. I didn't want the email to look boring. I wanted the "insults" (the bold text) to pop in different colors.

We use Python's re (Regex) and itertools to find every <strong> tag my bot generates and cycle through a "Dracula" color palette to inject inline CSS styles.

import os
import smtplib
import markdown
import re
import itertools
from email.message import EmailMessage
from openai import OpenAI

# Configs (Loaded safely from GitHub Secrets)
POE_API_KEY = os.environ.get("POE_API_KEY")
EMAIL_ADDRESS = os.environ.get("EMAIL_ADDRESS")
EMAIL_PASSWORD = os.environ.get("EMAIL_PASSWORD")
LASTFM_URL = "https://www.last.fm/user/profoundlypaige"

# --- NEON PALETTE ---
# A list of bright colors that look good on dark backgrounds
# (Pink, Cyan, Green, Orange, Purple, Yellow)
COLORS = ["#FF79C6", "#8BE9FD", "#50FA7B", "#FFB86C", "#BD93F9", "#F1FA8C"]

def get_roast():
    """Pings the Poe API to get the roast."""
    client = OpenAI(api_key=POE_API_KEY, base_url="https://api.poe.com/v1")

    try:
        print("🔥 Fetching roast from Poe...")
        response = client.chat.completions.create(
            model="lastfm-roaster",
            messages=[
                {"role": "user", "content": f"Roast my music taste: {LASTFM_URL}"}
            ]
        )
        return response.choices[0].message.content
    except Exception as e:
        return f"Error fetching roast: {e}"

def inject_colors(html_content):
    """
    Finds every <strong> tag and injects a different color from the palette.
    """
    color_cycle = itertools.cycle(COLORS)

    def replace_match(match):
        next_color = next(color_cycle)
        # Returns <strong style="color: #CODE">
        return f'<strong style="color: {next_color}">'

    # Regex to replace <strong> with the colored version
    return re.sub(r'<strong>', replace_match, html_content)

def create_html_email(roast_text):
    # 1. Convert Markdown to basic HTML
    raw_html = markdown.markdown(roast_text)

    # 2. Inject the rotating neon colors into bold tags
    colorful_html = inject_colors(raw_html)

    # 3. Wrap in the styled container
    html_template = f"""
    <!DOCTYPE html>
    <html>
    <head>
    <style>
        body {{ margin: 0; padding: 0; background-color: #121212; font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif; }}

        .container {{ 
            max-width: 600px; 
            margin: 40px auto; 
            background-color: #1e1e1e; 
            border-radius: 16px; 
            overflow: hidden; 
            box-shadow: 0 10px 30px rgba(0,0,0,0.5); 
            border: 1px solid #333;
        }}

        .header {{ 
            background: linear-gradient(135deg, #2b2b2b 0%, #1a1a1a 100%); 
            padding: 30px; 
            text-align: center; 
            border-bottom: 2px solid #333;
        }}

        /* The title is now a gradient text effect */
        .header h1 {{ 
            margin: 0; font-size: 28px; letter-spacing: 2px; text-transform: uppercase; 
            background: -webkit-linear-gradient(#FF79C6, #8BE9FD);
            -webkit-background-clip: text;
            -webkit-text-fill-color: transparent;
        }}

        .content {{ padding: 30px; color: #d1d5db; line-height: 1.7; font-size: 16px; }}

        h2 {{ 
            color: #ffffff; 
            border-left: 5px solid #BD93F9; /* Purple accent */
            padding-left: 15px;
            margin-top: 30px; 
            text-transform: uppercase;
            font-size: 18px;
            letter-spacing: 1px;
        }}

        ul {{ padding-left: 20px; }}
        li {{ margin-bottom: 10px; }}

        /* Styles for links */
        a {{ color: #8BE9FD; text-decoration: none; border-bottom: 1px dotted #8BE9FD; }}

        .footer {{ 
            background-color: #121212; 
            padding: 20px; 
            text-align: center; 
            font-size: 12px; 
            color: #555; 
        }}
    </style>
    </head>
    <body>
        <div class="container">
            <div class="header">
                <h1>🔥 The Daily Burn</h1>
            </div>
            <div class="content">
                {colorful_html}
            </div>
            <div class="footer">
                Served fresh by Poe API, Gemini 2.5 Flash, & GitHub Actions<br>
                <a href="{LASTFM_URL}" style="color:#555; border:none;">View your tragic Last.fm Profile</a>
            </div>
        </div>
    </body>
    </html>
    """
    return html_template

def send_email(roast_text):
    msg = EmailMessage()
    msg["Subject"] = "Your Daily Last.fm Roast 🎸"
    msg["From"] = EMAIL_ADDRESS
    msg["To"] = EMAIL_ADDRESS
    msg.set_content(roast_text)
    msg.add_alternative(create_html_email(roast_text), subtype='html')

    try:
        with smtplib.SMTP_SSL("smtp.gmail.com", 465) as smtp:
            smtp.login(EMAIL_ADDRESS, EMAIL_PASSWORD)
            smtp.send_message(msg)
        print("✅ Email sent successfully!")
    except Exception as e:
        print(f"❌ Failed to send email: {e}")

if __name__ == "__main__":
    roast = get_roast()
    send_email(roast)

Automating with GitHub Actions 🤖

I don't want to run this manually -- I want to be roasted automatically. So we'll use a GitHub Actions workflow to run this script every day at 12:00 UTC.

To create .github/workflows/daily_roast.yml:

name: Daily Lastfm Roast
on:
  schedule:
    - cron: '0 12 * * *' # Noon UTC, every day

jobs:
  roast:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-python@v2
        with:
          python-version: '3.9'
      - run: pip install -r requirements.txt
      - run: python lastfm_roast.py
        env:
          POE_API_KEY: ${{ secrets.POE_API_KEY }}
          EMAIL_ADDRESS: ${{ secrets.EMAIL_ADDRESS }}
          EMAIL_PASSWORD: ${{ secrets.EMAIL_PASSWORD }}

Is it worth it? 💸

This is my favorite part. Poe charges "Compute Points" to run the underlying model that powers the bot (I used Gemini 2.5 Flash for the backend of my bot). I checked my consumption after a few test runs to see what kind of bill I was racking up:

Here is the breakdown from my dashboard:

Model: Gemini 2.5 Flash
Cost per Request: ~161 Compute Points
Dollar Cost: ~$0.0048 per roast

If I run this every single day for a year:
$0.0048 * 365 days = $1.75

$1.75 per year.

For less than two bucks, I can get a state-of-the-art LLM to analyze my listening trends and tell me my taste in indie pop is "derivative and sad" every single morning. That is high-value ROI. 📈

The Result: Before vs After

Before (Chat Interface):
Trapped in an app. Hard to share. Markdown text.

After (The Neon Upgrade):

Now, when I open my email, I get a sleek, dark-mode card. The band names—the targets of the insults—are highlighted in Pink, Cyan, and Green, making sure I don't miss exactly who I'm being mocked for listening to.

And because it's an email, I can instantly forward the roast to my friends so they, too, can laugh at my pain.

Wrapping Up

This pattern (Custom Bot + API + HTML Generation + Actions) is my go-to for almost all my personal automation. It’s robust, free to host, and creates genuinely fun daily interactions.

Repositories mentioned:

Let me know in the comments if you try this out, or share the worst roast the AI gave you, and happy coding! ✨

Where we're going, we don't need chatbots: introducing the Antigravity IDE 🚀

Paige Bailey — Tue, 23 Dec 2025 02:19:15 +0000

Lately, I’ve been living in a new world—specifically, a world called Antigravity. It’s the agent-first IDE that the Google DeepMind team has been building, and honestly? It’s completely ruined "normal" coding for me.

We talk a lot about AI in development, but most of the time this just ends up being a chat box in the browser. Antigravity is different - it's built on an "agent-first" architecture (shoutout to the Windsurf team who brought this idea to life!). The idea is that the AI shouldn’t just suggest code; it should be an autonomous partner that can navigate the terminal, the editor, and even a live browser to get things done. We're even starting to incorporate many of these agentic features into AI Studio's Build feature!

I wanted to share two specific features that have become absolute game-changers for my daily workflow.

QA testing and documentation on auto-pilot

If you're like me, the most exhausting part of any sprint isn't the code - it’s the housekeeping. You know the drill: you finish a feature, then you have to spend hours taking screenshots and writing detailed how-to guides for the quality assurance team and for users. It's incredibly important, but also tedious, work.

In Antigravity, I’ve started using the Browser Subagent (powered by Gemini 2.5 Computer Use) to handle this. I can literally just say: "Go to this staging site, identify five core user journeys, and make a tutorial for all of them."

The agent doesn't just "guess." It explores the DOM, interacts with elements, and records its progress. But the "secret sauce" is the Artifacts System. Instead of a wall of text, the agent produces a Walkthrough Artifact - which is a structured, human-readable document complete with verification results, detailed steps expressed as text, and screenshots.

// Detect dark theme var iframe = document.getElementById('tweet-2003159982464696827-445'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2003159982464696827&theme=dark" }

Because Antigravity supports asynchronous feedback, I can hop into that Implementation Plan or Walkthrough and leave Google Docs-style comments directly on the text or screenshots - there's no black box. The agent reads my feedback in real-time and adjusts its next steps without me having to restart the whole task.

Toolkit for Antigravity extension

If you’re pushing the limits of agentic coding, you’re likely bouncing between models. I usually have Gemini 3 Pro handling complex architectural planning while Gemini 3 Flash handles the high-velocity subtasks.

Keeping track of your quota (token consumption) across Google AI Studio, Anthropic's models (Opus, Sonnet), and OpenAI's models is usually a nightmare. Luckily, a community member built an incredible open-source extension called Toolkit for Antigravity (you can find it on the OpenVSX marketplace).

// Detect dark theme var iframe = document.getElementById('tweet-2003052007192772726-87'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2003052007192772726&theme=dark" }

It adds these sleek Semi-Arc Gauges to your sidebar that show:

Real-time Quota Tracking: Hour-by-hour stats for Gemini, Claude 4.5, and the OpenAI GPT models.
Cache Management: A one-click way to browse and purge conversation caches when things get a bit "loopy."
Privacy First: It’s 100% local with no telemetry, which is a must for those of us working in enterprise repos.

Shifting to "Manager View"

The biggest mental shift with Antigravity is moving from the Editor View to the Manager View. In the Editor, you’re writing code; in the Manager, you’re an architect overseeing multiple agents working in parallel.

Whether you’re refactoring a legacy auth module or having an agent vibe code a new frontend from scratch, the goal is to keep you building without distractions. Antigravity handles the terminal commands, the dependency installs, and the UI verification so you can focus on what you're building instead how.

So anyhow, I’m curious - what’s the one part of your development workflow you wish you could just hand off to an agent today? For me, one of the top instances was definitely the "screenshotting for tutorials", and I’m never going back.

Catch you in the comments! ✌️

Give your AI Studio deployed app a custom URL

Paige Bailey — Thu, 11 Dec 2025 17:55:08 +0000

So, you’ve just built an incredible AI application using Build in Google’s AI Studio. You hit Deploy, the code flies through the ether, and your app is live! But then you look at the URL. It’s something like: https://burning-man-animal-cuddle-614365371127.us-west1.run.app/.

While I personally love the vibe of "Burning Man Animal Cuddle", your users might find it a bit... suspicious. You bought a cool domain on Namecheap (like vibe-compose.com), and you want to use that instead.

If you’ve never connected a Google Cloud Run service to a third-party registrar like Namecheap, the "DNS Dance" can be confusing. Here is exactly how to do it without pulling your hair out.

Step 1: Add the Mapping in Cloud Run

First, head over to your Google Cloud Console and navigate to Cloud Run domains. Find your project in the dropdown list in the top left (ex: Generative Language Client). You’ll see a button to Add Mapping in the Domain Mappings section.

In the dropdown:

Select service: Pick your app.
Select a verified domain: Choose "Verify a new domain..."
Base domain: Type your root domain (e.g., vibe-compose.com). Do not type www yet. We start with the root.

Step 2: The Verification Dance

Google needs to know you actually own the domain before they route traffic to it. When you click verify, a modal will pop up giving you a TXT record.

Once you've entered in your website name and hit Continue, copy that long string of text. It's time to leave Google for a moment and head to Namecheap.

Log into Namecheap.
Go to your Domain List -> Manage -> Advanced DNS.
Click Add New Record.
Select TXT Record.
Host: @
Value: Paste that Google verification string here.
TTL: Automatic.
Save changes.

☕ Coffee Break: DNS changes usually take a while. Wait 2 minutes, then go back to the Google Cloud tab and press VERIFY.

Step 3: Mapping the "Naked" Domain

Once verified, the hard part begins. You want your site to load at vibe-compose.com (no www). This is called the "Naked" or "Root" domain.

Cloud Run does not use CNAMEs for root domains. It uses A Records (IPv4) and AAAA Records (IPv6). Cloud Run will display a list of IP addresses. You need to add all of them to Namecheap.

In Namecheap Advanced DNS, your list should look like the image above:

4 A Records: Host is @, Values are the IPs ending in .32.21, .34.21, .36.21, and .38.21.
4 AAAA Records: Host is @, Values are the long IPv6 addresses.

Step 4: Don't Forget the `www`

If you stop now, vibe-compose.com will work, but www.vibe-compose.com will crash. We need to map the subdomain too.

Go back to Cloud Run Domain Mappings.
Click Add Mapping again.
Type www.vibe-compose.com.
Google will tell you to add a CNAME.
Back in Namecheap, add one final record:
Type: CNAME Record
Host: www
Value: ghs.googlehosted.com.

⚠️ The "Gotcha": Many devs accidentally paste ghs.googlehosted.com into the "Host" field. Don't do that! The Host is www. If Namecheap adds a period at the end, that should be okay.

Step 5: The spinning wheel of patience

Once your DNS records are in, head back to the Cloud Run dashboard. You will see your domains listed with a yellow spinner or a green checkmark.

What is happening now?

DNS Propagation: Google is checking to see if Namecheap updated (can take 10 mins to 24 hours).

Certificate Provisioning: Once DNS is found, Google automatically creates a managed SSL certificate for you.

Conclusion

Taking the extra 5 minutes to map a custom domain adds a massive layer of polish to your projects. Now, instead of sending people to burning-man-animal-cuddle, you can send them to vibe-compose.com.

(Though, honestly, I'm going to miss the animal cuddles).

Happy Coding! 🚀

I built a product "BS Detector" using Gemini 2.0 Flash and AI Studio 🕵️‍♂️

Paige Bailey — Wed, 19 Nov 2025 05:33:43 +0000

Let's be honest: online product reviews are often... broken. You see a gadget with 4.8 stars, but when you dig in, the reviews are either bots, "incentivized" reviews, or people who used the product for 5 minutes.

I got tired of tab-switching between Amazon, Reddit, and YouTube to find the actual truth about a product. So, I built a Chrome Extension to do it for me! It’s called The BS Detector.

It lives in the Google Chrome Side Panel, scrapes the product name, and uses Google Gemini 2.0 Flash (with Search Grounding) to cross-reference the product against real discussions on Reddit and independent forums. You could also use Gemini 2.5 Flash-Lite, or Gemini 2.5 Flash.

Here is how I built it, the tech stack I used, and the "Aha!" moment regarding JSON schemas.

The Tech Stack

I wanted to keep this lightweight, which meant no backend server. That means that the user has to supply their own API key, but the footprint for project files is pretty minimal:

Manifest V3: The standard for modern Chrome Extensions.
Chrome Side Panel API: Better than a popup because it stays open while you browse.
Gemini 2.0 Flash: Fast, cheap (free tier available), and supports Google Search Grounding.
Vanilla JS & CSS: Because sometimes you don't need a framework.

1. The manifest and side panel

Popups are annoying for research tools because they close when you click away. The Side Panel is the perfect UX for this.

In manifest.json, we define the behavior:

"side_panel": {
  "default_path": "sidepanel.html"
},
"permissions": ["sidePanel", "activeTab", "scripting", "storage"]

And in background.js, we ensure the panel opens when the icon is clicked:

chrome.sidePanel
  .setPanelBehavior({ openPanelOnActionClick: true })
  .catch((error) => console.error(error));

2. Getting the context

When the user clicks "Analyze," we need to know what they are looking at. I used chrome.scripting to inject a quick function into the active tab to grab the title.

We look for specific Amazon ID selectors first, then fall back to the <h1> tag.

chrome.scripting.executeScript({
    target: { tabId: tab.id },
    func: () => {
        const amzn = document.getElementById('productTitle');
        const h1 = document.querySelector('h1');
        return amzn ? amzn.innerText : (h1 ? h1.innerText : document.title);
    }
}, (results) => {
    // Update UI with product title
});

3. Gemini 2.0 Flash + Search grounding

This is where the magic happens. It isn't a secret that LLMs hallucinate - as an example, if I ask GPT-4 about a specific generic dropshipped air purifier, it might make up features or capabilities.

To fix this, I used Gemini's Search Grounding. This allows the model to query Google Search live during generation.

Here is the prompt strategy I used in sidepanel.js:

const prompt = `
You are a cynical consumer investigator. Analyze this product: "${productTitle}".

1. Use Google Search to find discussions on Reddit, YouTube, and independent forums.
2. Ignore marketing fluff. Look for "dealbreakers".
3. Determine if this is a high-quality item or generic "dropshipped" junk.
`;

I pass tools: [{ googleSearch: {} }] in the API payload. This tells Gemini: "If you don't know, Google it."

4. Controlled JSON output

The biggest pain in AI engineering is parsing the response. You usually get markdown, backticks, or conversational filler ("Here is the JSON you asked for...").

Gemini 2.0 supports Controlled Generation via responseSchema. You can define exactly what the JSON should look like, and the API enforces it. Which means no more Regex parsing!

generationConfig: {
    responseMimeType: "application/json",
    responseSchema: {
        type: "OBJECT",
        properties: {
            real_score: { type: "NUMBER" },
            verdict: { type: "STRING" },
            dealbreakers: { 
                type: "ARRAY", 
                items: { type: "STRING" } 
            },
            pros: { 
                type: "ARRAY", 
                items: { type: "STRING" } 
            },
            source_count: { type: "NUMBER" }
        },
        required: ["real_score", "verdict", "dealbreakers", "pros"]
    }
}

Because of this schema, in my fetch request, I can simply do:

const data = await response.json();
const analysis = JSON.parse(data.candidates[0].content.parts[0].text);
// It just works. Every time.

The results

The extension takes the product title, reads through the "BS" marketing, checks Reddit threads about the item, and outputs:

A Real Sentiment Score: (e.g., 6.5/10).
The Verdict: A concise summary of actual user experiences.
Dealbreakers: The stuff Amazon hides (e.g., "proprietary charging cable," "app requires login").

// Detect dark theme var iframe = document.getElementById('tweet-1990887860237414821-994'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1990887860237414821&theme=dark" }

TL;DR

This project took a few minutes to build in AI Studio, but saves me time every time I shop. It’s a great example of how powerful Search Grounding is when combined with client-side extensions. You don't need a massive backend to build useful AI tools anymore.

Future Improvements:

Add history storage to compare products.
Analyze the price history as well, to see how it's changed!
Detect specific "fake review" patterns in the text itself.

The code is open source (link below). Go fork it and stop buying junk: https://github.com/dynamicwebpaige/product-bs-detector

📻 I built an infinite 90s boombox with Gemini + Lyria (and it has an AI DJ!)

Paige Bailey — Tue, 18 Nov 2025 06:08:28 +0000

I recently built an experiment that I honestly can’t stop listening to. It’s a virtual, web-based Boombox. You tune the dial, the station changes, and the music crossfades in real-time.

But here is the kicker: The DJ is AI.

Every time you settle on a station, a dynamically generated voice (courtesy of Gemini text-to-speech) chimes in to introduce the track and the genre, totally context-aware. It feels like a ghost in the machine, and it was built using the Google Gen AI SDK, Lit, and the Lyria Real-Time model.

Here is how I built it.

// Detect dark theme var iframe = document.getElementById('tweet-1990544411953168752-279'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1990544411953168752&theme=dark" }

The Tech Stack

Vibe-coding Platform: Google AI Studio
Framework: Lit (Web Components) + Vite
Music Generation: Google's lyria-realtime-exp model
DJ Voice & Script: Gemini 2.5 Flash & Gemini TTS (Fenrir voice)
Visuals: CSS for the radio, Gemini 2.5 Flash Image for the background.

1. The Infinite Music Stream 🎵

The core of the app is the LiveMusicHelper. It connects to the lyria-realtime-exp model. Unlike generating a static MP3 file, this establishes a session where we can steer the music in real-time by sending "Weighted Prompts."

When you turn the tuning knob on the UI, we aren't downloading a new song; we are telling the AI to shift its attention.

// from utils/LiveMusicHelper.ts

public readonly setWeightedPrompts = throttle(async (prompts: Map<string, Prompt>) => {
  // Convert our UI map to an array for the API
  const weightedPrompts = this.activePrompts.map((p) => {
    return { text: p.text, weight: p.weight };
  });

  try {
    // This is where the magic happens. 
    // We tell the model: "be 100% Bossa Nova" or "mix 50% Dubstep and 50% Jazz"
    await this.session.setWeightedPrompts({
      weightedPrompts,
    });
  } catch (e: any) {
    console.error(e);
  }
}, 200);

The visual knob component maps a rotation angle to an index in a prompt array. If you are on index 0, "Bossa Nova" gets a weight of 1.0.

2. The AI DJ (The "Secret Sauce") 🎙️

This is my favorite part. A radio isn't a radio without a DJ telling you what you're listening to. I created a RadioAnnouncer class to handle this.

It works in a two-step chain:

Generate the Script: We ask Gemini to write a one-sentence intro.
Generate the Audio: We pass that text to the TTS model.

Step 1: The Personality

We prompt Gemini 2.5 Flash to adopt a persona. Note the specific constraints: short, punchy, no quotes.

// from utils/RadioAnnouncer.ts

const scriptResponse = await this.ai.models.generateContent({
  model: 'gemini-2.5-flash',
  contents: `You are a charismatic radio DJ. Write a single, short, punchy sentence to introduce the current song.
  The station frequency is ${freq} FM.
  The music genre is ${station}.
  Do not use quotes. Just the spoken text.
  Example: "You're locked in to 104.5, keeping it smooth with Bossa Nova."`,
});

Step 2: The Voice

We use the Fenrir voice from the prebuilt configurations.

const ttsResponse = await this.ai.models.generateContent({
  model: 'gemini-2.5-flash-preview-tts',
  contents: {
    parts: [{ text: script }]
  },
  config: {
    responseModalities: [Modality.AUDIO],
    speechConfig: {
      voiceConfig: {
        prebuiltVoiceConfig: { voiceName: 'Fenrir' }
      }
    }
  }
});

The Logic: Debouncing

Because the user might scroll past 5 stations quickly to get to "Dubstep," we don't want the DJ to try and announce every single one. I used a debouncer so the generation only triggers once the user stops turning the knob for 800ms.

3. The Aesthetics 🎨

The UI is built using Lit. The boombox itself is a mix of CSS styling and SVG for the speakers and knobs.

The Speaker Pulse:
I used the Web Audio API to create an AudioAnalyser. We grab the current frequency data and map it to a CSS transform: scale() on the speaker cones.

/* from components/PromptDjMidi.ts */
.speaker-cone {
  /* ... textures and gradients ... */
  transition: transform 0.05s cubic-bezier(0.1, 0.7, 1.0, 0.1);
}

// In the render loop
const pulseScale = 1 + (this.audioLevel * 0.15); 
const speakerStyle = styleMap({
    transform: `scale(${pulseScale})`
});

The Background:
To really sell the vibe, I generate a background image on load.

// The prompt used for the background
text: 'A 90s-style girl\'s bedroom, dreamy, nostalgic, vaporwave aesthetic, anime posters on the wall, lava lamp, beaded curtains, photorealistic.'

4. Managing the "Spin" 😵‍💫

One of the hardest parts of this build was the math for the tuning knob. We need to convert mouse/touch movement into rotation, and then snap that rotation to specific "stations."

I implemented a circular capture logic:

Calculate the angle between the center of the knob and the mouse cursor.
Calculate delta (change) from the start of the click.
Handle the 0/360 degree wrap-around logic so you can spin it endlessly.

// from components/PromptDjMidi.ts
private handlePointerMove(e: PointerEvent) {
  // ... math to get angle ...

  // Handle crossing the 0/360 boundary smoothly
  if (delta > 180) delta -= 360;
  if (delta < -180) delta += 360;

  this.rotation = (this.startRotation + delta + 360) % 360;

  // Map rotation to station index
  const index = Math.floor(((this.rotation + segmentSize/2) % 360) / segmentSize);
  this.setStation(index);
}

TL;DR

This project was a blast to build because it combines the tactile feel of old-school interfaces with bleeding-edge generative AI.

The "Ghost DJ" effect really adds a layer of immersion that pure generative music apps usually lack. It gives the AI a voice—literally—and makes the infinite radio feel alive.

You can check out the full code here in AI Studio: https://aistudio.google.com/apps/drive/1L23eufECJSn0KPta3eAVo-PGdM4iXm-1

Let me know if you try building your own stations! I'm currently vibing to 94.0 "Shoegaze." 📻

⛓️‍💥Chaining Veo 3.1 and NanoBanana with Gemini

Paige Bailey — Sat, 15 Nov 2025 04:45:23 +0000

As developers, we are used to chaining APIs to get a desired output. In the world of Generative AI, a similar pattern emerges: Model Chaining.

Creating a high-quality AI videos often requires orchestrating a workflow, not just typing in text and hitting the "generate!" button. Today, I’m going to walk through a specific stack—Gemini 2.5 Pro (for reasoning/prompting), NanoBanana (for base image generation), and Veo 3.1 (for image-to-video) to simulate a hyper-realistic doorbell security camera feed of a very cute fennec fox who is playing with LEGO bricks.

Below is the breakdown of how we went from a blank slate to a coherent video, the prompts I used in Google AI Studio, and a critique of the generated video output. Let's get started! 😄

The model chain

Gemini. Used to reason through the visual aesthetics and generate the complex prompts needed for the image and video generation models.
NanoBanana. Used to generate the initial static image asset, in portrait mode (9:16).
Veo 3.1 Fast. Used to apply physics and motion to the static image asset, also in portrait mode (9:16).

Phase 1: The Base Image

The hardest part of image generation is getting the "vibes" and the character consistency right. For this example, I wanted a specific medium — a grainy, night-vision security camera from the perspective of a home doorbell.

Instead of guessing keywords, I asked Gemini to act as a prompt engineer for the task at hand. I provided the concept ("Fennec fox, Legos, night, doorbell cam") and asked it to write a prompt for an image model.

The Gemini-Generated Prompt:

A grainy, low-quality doorbell camera snapshot at night. Infrared night vision aesthetic with a slight monochromatic green tint. A wide-angle fisheye lens view looking down at a front porch welcome mat. A cute fennec fox with large ears is sitting on the mat, looking up at the camera with glowing reflective eyes. The fox is surrounded by scattered LEGO bricks. The LEGO bricks are arranged on the floor to clearly spell out the word "HI :)" in block letters. Digital overlay text in the corner says "FRONT DOOR - LIVE" and the current timestamp.

Why this works:

Artifact Injection: Words like "grainy," "low-quality," and "monochromatic green tint" prevent the model from making the image too clean or artistic. It forces realism through imperfection.
Camera Specs: Specifying "fisheye lens" and "looking down" enforces the correct perspective distortion typical of Ring/Nest cameras.

The Result:
NanoBanana output a near-perfect static image. The lighting was flat (typical of IR), the eyes glowed (retro-reflection), and the angle was distinctively "doorbell."

Phase 2: The Animation

If you simply tell a video model "make it move," all of the models have a tendency to hallucinate wild camera pans or morph the subject. You need to provide direction. To do this, I fed the static image back into Gemini and asked it to write a prompt for animating the image. After taking a look at the example prompts, I selected one that focused on interaction and physics.

The Video Prompt:

The cute fennec fox looks down from the camera towards the LEGO bricks on the mat. It gently extends one front paw and nudges a loose LEGO brick near the "HI", sliding it slightly across the mat. The fox then looks back up at the camera with a playful, innocent expression. Its ears twitch. The camera remains static.

I fed this prompt and the static image into Veo 3.1 Fast.

Phase 3: Analyzing the Veo Output

Let’s look at the resulting video file and analyze the execution against the prompt:

// Detect dark theme var iframe = document.getElementById('tweet-1989549550046986570-109'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1989549550046986570&theme=dark" }

Wins

Temporal coherence (lighting and texture):
The most impressive aspect is the consistency of the night-vision texture. The "grain" doesn't shimmer uncontrollably, and the monochromatic green remains stable throughout the 7 seconds. The fur texture on the fox changes naturally as it moves, rather than boiling or morphing.
The "Fisheye" effect:
Veo 3.1 respected the distortion of the original image. When the fox leans down and back up, it moves within the 3D space of that distorted lens. It doesn't flatten out.
Ear dynamics:
The prompt specifically asked for "ears twitch." Veo nailed this. The ears move independently and reactively, which is a critical trait of fennec foxes. This adds a layer of biological realism to the generated movement.
Camera locking:
The prompt specified "The camera remains static." This is crucial. Early video models often added unnecessary pans or zooms. Veo kept the frame locked, reinforcing the "mounted security camera" aesthetic.

Bugs

Object Permanence ( The LEGOs):
While the prompt asked the fox to "nudge a loose LEGO," the model struggled with rigid body physics. Instead of a clean slide, the LEGOs near the paws tend to morph or "melt" slightly as the fox interacts with them. The "HI" text also loses integrity, shifting into abstract shapes by the end of the clip.
Motion Interpretation:
The prompt asked for a gentle paw extension. The model interpreted this more as a "pounce" or a head-dive. The fox dips its whole upper body down rather than isolating the paw. While cute, it’s a deviation from the specific articulation requested.
Text Overlay (OCR Hallucination):
The original image had a crisp timestamp. As soon as motion begins, the text overlay ("FRONT DOOR - LIVE") becomes unstable. Video models still struggle to keep text overlays static while animating the pixels behind them. The timestamp blurs and fails to count up logically.
The "Welcome" Mat:
If you look closely at the mat, the text (presumably "WELCOME") is geometrically inconsistent. As the fox moves over it, the letters seem to shift their orientation slightly, revealing that the model treats the mat as a texture rather than a flat plane in 3D space.

TL;DR

Using an LLM like Gemini to generate prompts for media models is a massive efficiency booster! And while Veo 3.1 Fast demonstrates incredible understanding of lighting, texture, and biological movement (the ears!), it can — like all current video models — still face challenges with rigid object interaction (LEGOs) and static text overlays.

Quick tips: Be specific about camera angles and lighting in your text-to-image phase. In the video phase, focus your prompts on the subject's movement, but expect some fluidity in the background objects. And use Gemini 2.5 Pro to help with prompting.

I Cloned Myself in 2 Minutes to Answer Gemini API Questions

Paige Bailey — Wed, 12 Nov 2025 19:25:55 +0000

Experimenting with Happyverse 2.0

As developers, we are obsessed with automation. We automate our deployments, our testing, and our linting. But the one thing we’ve never quite been able to scale is ourselves.

Until recently.

I decided to take Happyverse 2.0 for a spin to see if I could build a digital twin capable of handling the technical questions I get bombarded with daily. Specifically, I wanted to see if an AI clone could handle queries about Google AI Studio and the Gemini APIs with enough accuracy to pass as me.

// Detect dark theme var iframe = document.getElementById('tweet-1988420687246356930-659'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1988420687246356930&theme=dark" }

The "Time to Hello World"

The setup time was the most surprising metric. It took approximately 2 minutes to go from zero to a fully rendered clone, with the assistance of the Happyverse UI.

In the world of AI avatars, we usually expect a trade-off between rendering latency and visual fidelity. However, the result here was frighteningly close to real life. We aren't just talking about a static chatbot; this is a real-time participant in a meeting — an intersection of a lifelike avatar and an intelligent agent. You can also dial into Google Meet instances, Zoom meetings, and more with your generated Happyverse agents.

Use Case: Technical Support Agent

I pointed the clone at a URL for our Gemini API documentation. The goal? To see if "She" could accurately parse and explain API endpoints and studio features without hallucinating.

The results were impressive. She handled the context well, staying tied to the real data and DeepMind models rather than hallucinating answers, or answering off-topic questions. This "grounding" is critical for developers looking to build agents that serve as actual product experts rather than just conversational novelties.

Edge Cases and "Human" Latency

While the technical accuracy is there, the "human" element is the next frontier of optimization.

Personality Injection: She’s accurate, but she needs a crash course in Texas barbecue to truly pass as me. Customizing the system prompt, adding more docs for grounding, and specific tonal quirks is the next step.
i18n: I’m planning to test multilinguality next. Can the avatar switch context to German on the fly while maintaining lip-sync accuracy? That’s a stress test I’m looking forward to.

The Stack

For those curious about the platform, this was built on Happyverse 2.0. They position themselves as a platform for building "Confidants"—essentially AI agents wrappered in hyper-realistic video generation that operates in real-time.

If you are looking to build interfaces that feel less like a terminal and more like a colleague, this is worth a look.

Check out Happyverse 2.0 on Product Hunt:
https://producthunt.com/products/happyverse-2

How I Built a "Community Prayer Quilt" in 5 Minutes

Paige Bailey — Wed, 12 Nov 2025 19:13:27 +0000

Stack: Google AI Studio + Google Sheets + Google Forms + Gemini 2.5 Flash-Lite

We’ve all been there: you have an idea for a sweet, community-focused project, but the thought of spinning up a database, configuring auth, and building a backend API stops you before you even npm init.

This weekend, I decided to skip the boilerplate and ship.

I wanted to build a Community Prayer Quilt—a digital space where people could leave a prayer or wish, and have it stitched into a visual tapestry. The goal was to get it running in the time it takes to brew coffee.

Here is the "lazy" architecture I used to build prayerwall.club in about 5 minutes, using Google Sheets as my backend and Gemini 2.5 Flash-Lite as my content moderator.

// Detect dark theme var iframe = document.getElementById('tweet-1988056184365216128-354'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1988056184365216128&theme=dark" }

The "No-Backend" Architecture

When you need to collect user data rapidly without a server, nothing beats the Google ecosystem's plumbing.

1. The Database & Ingestion: Google Forms + Sheets
Instead of building a React form and handling POST requests, I created a Google Form.

Input: Users submit their prayers via the form.
Storage: Responses are automatically piped into a Google Sheet.

2. The API: Sheets CSV Export
Here’s a trick I love for hackathons. You don’t need the full Google Sheets API (and its OAuth dance) for public read-only data. You can publish a sheet to the web and access it via the visualization endpoint:

const SHEET_ID = 'YOUR_SHEET_ID';
const URL = `https://docs.google.com/spreadsheets/d/${SHEET_ID}/gviz/tq?tqx=out:csv`;

// Fetch and parse
const response = await fetch(URL);
const csvText = await response.text();
// ...parse CSV to JSON...

Boom. Instant, zero-latency JSON endpoint.

The AI Bouncer: Gemini Flash-Lite

The problem with public walls is moderation. I didn't want to manually review every entry, but I also didn't want to risk trolls posting toxicity on a prayer wall.

Enter Gemini Flash-Lite via Google AI Studio.

I needed something fast and cheap to act as a "toxicity check" before rendering the prayers on the quilt. I hooked up the @google/genai SDK to run a quick sanity check on the frontend.

Here is the prompt logic I used:

const model = genAI.getGenerativeModel({ model: "gemini-flash-lite-latest" });

const prompt = `
  Analyze the following prayer for safety. 
  It will be displayed on a public, all-ages community wall.
  The prayer must not contain toxic language, hate speech, or violence.

  Prayer: "${userPrayer}"

  Return JSON: { "is_safe": boolean }
`;

If is_safe returns true, the patch is stitched into the quilt. If not, it’s silently discarded. It adds a tiny bit of latency, but it ensures the vibe of the site remains wholesome without me having to play internet janitor.

The Visuals: Procedural HTML5 Canvas

For the frontend, I didn't want a simple list. I wanted it to look like a quilt.

I used React with the HTML5 <canvas> API to procedurally generate each "patch."

Seeding: I hash the prayer text to create a unique seed.
Pattern: That seed determines the fabric color palette, the stitch patterns (sine waves), and the "fabric texture" (randomized stroke opacity).

This means every prayer generates a unique, deterministic visual representation of itself.

Why This Matters

Is this "Enterprise Grade"? Absolutely not. Is it scalable to millions of users? Probably not (Google Sheets has rate limits).

But it is live.

We often let architectural purity get in the way of shipping. By treating Google Sheets as a backend and using a lightweight AI model for logic that would essentially require a human human, I went from "idea" to "deployed" in minutes.

Check it out live here: prayerwall.club

Go build something fun today. Worry about the migration to a more robust database later.

We're the Google DeepMind Team building Gemini, Google AI Studio, and more! Ask Us Anything.

Paige Bailey — Tue, 19 Aug 2025 19:08:46 +0000

Hey DEV community! 👋

We're the team behind Google AI Studio and the Gemini API at Google DeepMind.

We'll be answering your questions live on August 28, 2025 starting at 1PM ET.

Thank you to everyone who participated in our AMA! We'll do our best to keep answering questions asynchronously throughout the next few weeks so check back later if your question wasn't answered!

Who we are:

Paige Bailey (@dynamicwebpaige): AI Developer Relations Lead
Patrick Loeber (@pat_loeber): Developer Relations Engineer
Alisa Fortin (@alisa_fortin): Product Manager
Ivan Solovyev (@ivan_solovyev): Product Manager
Kate Olszewska (@kate_olszewska): Product Manager
Vivian Jair (@vivjair): Product Marketing Manager
Dave Elliot (@dave_elliott): Head of Developer Advocacy (Google Cloud)

What we work on:

🤖 AI Studio: Our developer platform where you can experiment with Gemini models, including access to our latest experimental releases.
🔧 Gemini API: APIs that serve millions of developers and process trillions of tokens.
🎨 Multi-modal & Open-Source Models: Advanced AI models including Veo (video generation), Imagen (image generation), Lyria (music creation), and Gemma (open-source language models).
📚 Developer Experience: Making Google's most advanced AI models easier to integrate and use.
🌍 Community: Building resources, documentation, and support for the global developer community.

Ask us about:

🚀 AI Studio & Gemini API: Features and how to get started
🎨 Our AI Models: Veo, Imagen, Lyria, Gemma
🔬 Working at Google DeepMind: What it's like being at the intersection of research and developer tools
🛠️ Building AI applications: Best practices, common challenges, scaling tips
💡 Career advice: Breaking into AI/ML, developer relations, product management
🌟 The future of AI development: Where we see the space heading
🏗️ Developer experience: How we think about making AI accessible

Please don't ask us about:

Unreleased Google products or detailed internal roadmaps
Proprietary technical implementations
Confidential business information
Personal/private information

Get started with AI Studio:

If you haven't tried AI Studio yet, it's the easiest way to start building with Gemini. You can turn on features like code execution, use extended context (2M+ tokens), and access our latest experimental models - all for free to get started!

We'll be rotating through answers throughout the day, so you might hear from different team members. Let's dive in! 🔥

DEV Community: Paige Bailey

Vandalizing My Own Wikipedia Experience: A 90s Cyberpunk GeoCities Makeover

Grounding Gemini with Wikipedia-specific syntax

Breaking down the script

1. The Marquee Title

2. The Sparkle Trail (A Lesson in Throttling)

3. The Mathematics of Walking Cats

The final results

🦖 Image Manipulation on a Budget: Bounding Boxes and Transparency with Gemini 3.0 Flash and NanoBanana Pro

Tech Stack

Use Case 1: The Transparent T-Rex 🕶️🦖

The Prompt:

The Model's "Thinking" Process 🧠

The Execution 💻

Use Case 2: Object Detection (The LEGO Test) 🧱

The Prompt:

The Logic 🧠

The Cost? 💸

Use Case 3: Transparency 🏁

Why this matters 💡

Benchmarking on a Budget: Running massive evals for 50% less with the Gemini Batch API ⚡️

The stack

Step 1: Preparing the Data

Step 2: Upload the data to Google Cloud

Step 3: Downloading the results

Step 4: Evaluations

Step 5: The results!

🥁 Drumroll please...

Final thoughts

Building a Neon-Soaked Last.fm Roast Bot for $1.75/Year

Building the Bot 🤖

Keys and Secrets 🗝️

1. Get the Keys

2. Store them in GitHub

Step 3: The Code 🐍

The "Neon" Script (lastfm_roast.py)

Automating with GitHub Actions 🤖

Is it worth it? 💸

The Result: Before vs After

Wrapping Up

Where we're going, we don't need chatbots: introducing the Antigravity IDE 🚀

QA testing and documentation on auto-pilot

Toolkit for Antigravity extension

Shifting to "Manager View"

Give your AI Studio deployed app a custom URL

Step 1: Add the Mapping in Cloud Run

Step 2: The Verification Dance

Step 3: Mapping the "Naked" Domain

Step 4: Don't Forget the www

Step 5: The spinning wheel of patience

What is happening now?

Conclusion

I built a product "BS Detector" using Gemini 2.0 Flash and AI Studio 🕵️‍♂️

The Tech Stack

1. The manifest and side panel

2. Getting the context

3. Gemini 2.0 Flash + Search grounding

4. Controlled JSON output

The results

TL;DR

📻 I built an infinite 90s boombox with Gemini + Lyria (and it has an AI DJ!)

The Tech Stack

1. The Infinite Music Stream 🎵

2. The AI DJ (The "Secret Sauce") 🎙️

Step 1: The Personality

Step 2: The Voice

The Logic: Debouncing

3. The Aesthetics 🎨

4. Managing the "Spin" 😵‍💫

TL;DR

⛓️‍💥Chaining Veo 3.1 and NanoBanana with Gemini

The model chain

Phase 1: The Base Image

Phase 2: The Animation

Phase 3: Analyzing the Veo Output

Wins

Bugs

TL;DR

I Cloned Myself in 2 Minutes to Answer Gemini API Questions

Experimenting with Happyverse 2.0

The "Neon" Script (`lastfm_roast.py`)

Step 4: Don't Forget the `www`