The Bug With No Error Message

I tried to set a short clip as my Telegram profile video. Recorded it on my iPhone, opened Telegram, picked the file, hit save. Telegram took it, showed a spinner for a second, then kept my old photo. No error. No toast. Nothing happened.

I tried three more times. Same silent nothing. The file played fine in every other app, so it wasn’t corrupt.

The problem is the codec. Since iOS 11, iPhones record video in HEVC (H.265) by default. It’s great for storage. It is also not what Telegram wants for a profile video avatar. Telegram’s avatar slot expects H.264, and when it gets something it can’t decode for that slot, it doesn’t tell you. It just drops the upload.

So I wrote a bot that re-encodes the file before it ever reaches that slot. This post is how it works.

What Telegram Actually Wants From a Video Avatar

There is no public error message, so I pieced the spec together by testing files until they stuck. A video avatar that Telegram accepts looks like this:

• Container: MP4.
• Video codec: H.264. libx264 is fine.
• Pixel format: yuv420p. HEVC files are often yuv420p10le (10-bit), which the H.264 avatar path rejects.
• Shape: square. I use 800×800. Non-square files get center-cropped by Telegram in ways you don’t control.
• Duration: 10 seconds or less.
• Size: 2 MB or less.
• Audio: none. The avatar has no sound, and an audio track sometimes pushes you over the size cap for nothing.
• faststart: the moov atom belongs at the front of the file so playback can begin before the whole thing downloads.

Miss any one of these and you get the silent drop. The 10-bit pixel format caught me out the longest, because the file looked completely valid.

Fixing It With ffmpeg

ffmpeg does all the real work here. I just call it correctly.

The first step is finding a square crop. iPhone video is 16:9 or 4:3, never square, so I need a 1:1 region. cropdetect scans a few seconds and reports a crop rectangle:

ffmpeg -i input.mov -t 3 -vf cropdetect=24:16:0 -f null - 2>&1 
  | awk '/crop=/ { c=$NF } END { print c }'

That prints something like crop=1080:1080:420:0. It centers on the actual content instead of blindly cropping from a corner.

Then the real encode:

ffmpeg -i input.mov 
  -t 10 
  -vf "crop=1080:1080:420:0,scale=800:800:flags=lanczos,format=yuv420p" 
  -c:v libx264 -profile:v high -preset slow -crf 28 
  -an 
  -movflags +faststart 
  -y output.mp4

Going through the flags that matter:

• -t 10 hard-caps the clip at 10 seconds.
• The -vf chain crops to square, scales to 800×800 with the Lanczos filter (sharper than the default bilinear), and forces format=yuv420p so the 10-bit problem disappears.
• -c:v libx264 is the codec swap. HEVC goes in, H.264 comes out.
• -crf 28 trades a little quality for size. At 800×800 it looks fine and helps stay under 2 MB.
• -an drops the audio track completely.
• -movflags +faststart moves the moov atom to the front.

One encode, every requirement satisfied.

Wiring It Into an aiogram 3 Bot

I wrapped this in a Telegram bot with aiogram 3 so I never have to think about it again. The handler accepts video, animation (GIFs arrive as animation), and raw document uploads:

import asyncio
from pathlib import Path
from aiogram import Bot, Dispatcher, F
from aiogram.types import Message, FSInputFile

dp = Dispatcher()


@dp.message(F.video | F.animation | F.document)
async def handle_video(message: Message, bot: Bot) -> None:
    media = message.video or message.animation or message.document
    if media is None:
        return

    src = Path(f"/tmp/{media.file_unique_id}.src")
    dst = Path(f"/tmp/{media.file_unique_id}.mp4")
    await bot.download(media, destination=src)

    await message.answer("Re-encoding to Telegram avatar format...")
    ok = await convert_to_avatar(src, dst)
    if not ok:
        await message.answer("Couldn't convert that one. 4K and HDR aren't handled yet.")
    else:
        await message.answer_video(FSInputFile(dst))

    src.unlink(missing_ok=True)
    dst.unlink(missing_ok=True)

The conversion runs ffmpeg as a subprocess and checks the output before trusting it:

async def convert_to_avatar(src: Path, dst: Path) -> bool:
    vf = "crop=in_h:in_h,scale=800:800:flags=lanczos,format=yuv420p"
    cmd = [
        "ffmpeg", "-i", str(src), "-t", "10",
        "-vf", vf,
        "-c:v", "libx264", "-preset", "slow", "-crf", "28",
        "-an", "-movflags", "+faststart", "-y", str(dst),
    ]
    proc = await asyncio.create_subprocess_exec(
        *cmd,
        stdout=asyncio.subprocess.DEVNULL,
        stderr=asyncio.subprocess.DEVNULL,
    )
    await proc.wait()
    if proc.returncode != 0 or not dst.exists():
        return False
    return dst.stat().st_size <= 2 * 1024 * 1024

For the bot I use crop=in_h:in_h, a center square based on input height. It skips the separate cropdetect pass and keeps latency low. cropdetect is the better choice when framing matters more than speed.

Packaging It As a Bot Anyone Can Use

Once it worked for me, sharing it was almost free. Send a video to the bot, get back a file that drops straight into the Telegram avatar slot. No app, no settings, no codec knowledge required. It lives here: https://t.me/LiveAvaBot?start=devto_article_20260520

The whole thing is one ffmpeg call behind a message handler. ffmpeg is doing the heavy lifting. I just wrote the wrapper that knows the exact spec Telegram never documents.

Edge Cases And What’s Next

A few things I learned shipping it:

• Size overshoot. A busy 10-second clip can still land above 2 MB at crf 28. The fix is a second pass with a higher crf, bumping it 4 or 5 at a time until the file fits.
• Rotation metadata. iPhone videos carry a rotation flag instead of rotating pixels. ffmpeg honors it by default now, but older builds can hand you a sideways avatar.
• GIFs. They arrive as animation, not video, which is why the handler filter includes both. After encoding they behave like any other clip.
• 4K and HDR. Not handled yet. HDR needs a tone-mapping step before the H.264 conversion or the colors wash out. That is next on the list.

Telegram silently rejecting valid-looking files is annoying. The fix turned out small once you know what the avatar slot wants: one ffmpeg call behind a message handler.

Built by me, @liveavabot.

Originally published on NextFuture

This post answers one question: does Braintrust’s $249/month Team plan justify its $150/month premium over LangSmith Plus ($99/month) as of May 2026. If you’re an AI engineer or technical PM shipping a production LLM feature, here’s the math before you click “upgrade.” Below 50,000 traces/month and a team smaller than five, LangSmith Plus wins on price. Above that threshold — and if your team catches even two production regressions per quarter — Braintrust’s $150/month premium pays for itself.

TL;DR: the verdict

WorkloadBraintrust/moLangSmith/moWinnerWhy

Light — solo dev, <5K traces/mo$249$0 (Free tier)LangSmith FreeLangSmith Free covers 5,000 traces/month. Braintrust Team costs $249 for a workload that fits on the free plan.
Medium — team of 5, ~50K traces/mo$249$99 (Plus)LangSmith Plus on price$150/month delta buys richer CI eval and dataset versioning — only worth it if your team prevents ≥2 incidents/quarter.
Heavy — scaling product, 500K+ traces/mo$249$99 (Plus)Braintrust on valueBoth are flat-fee at this scale. Braintrust’s automated regression suite and human-review queue save 2+ engineering hours per incident caught.

Short answer: LangSmith Free wins for solo work; LangSmith Plus wins for budget-constrained teams; Braintrust wins only if you can show it preventing incidents worth more than $150/month in engineering time.

What each one actually costs

Braintrust pricing breakdown

• Hobby (free): $0/mo — trace limit not published by vendor; use only for solo experiments. Source.

• Team: $249/mo — unlimited traces, team collaboration, dataset versioning, CI/CD integrations, prompt playground, and human review queue. The feature set that makes CI eval automation practical for a team of 3+. Source.

• Enterprise: Vendor doesn’t publish this — see footnote. Includes SSO, custom data retention, and SLA guarantees.

Hidden cost: Braintrust’s value is downstream of setup time. Expect 4–6 hours to wire eval harnesses into your CI pipeline and 1–2 weeks before the team writes enough golden datasets to make automated scoring reliable. That’s $400–$600 in engineering time before the tool delivers a verdict.

LangSmith pricing breakdown

• Free: $0/mo — 5,000 traces/month, one workspace, community support only. At 100 API calls/day that’s 50 days of runway; at 1,000 calls/day it runs out in 5 days. Source.

• Plus: $99/mo — higher trace volume (exact cap not published in cited source — check vendor pricing page before committing), team workspaces, annotation queues, and dataset management.

• Enterprise: Vendor doesn’t publish this — contact sales. Private deployment and dedicated support included.

Hidden cost: LangSmith traces every LangChain call by default. Teams not on the LangChain stack need to instrument manually with the LangSmith SDK, adding 1–2 hours per integration. No annual discount is published for Plus.

promptfoo (free alternative)

• Open Source: $0/mo — self-hosted, unlimited local test runs, no cloud trace storage. Requires you to provision storage, maintain the runner, and build your own team sharing workflow. Source.

promptfoo is the right call for a solo dev or a team willing to trade $99–$249/month for 4–8 hours of ops setup. It does not replace either product’s hosted collaboration or human review queue features.

Break-even, walked through

The pivot workload is the Medium bucket — a team of five shipping one or two AI features, generating roughly 50,000 traces per month. LangSmith Plus costs $99/month at that scale. Braintrust Team costs $249/month. The delta is exactly $150/month, or $1,800/year.

At an average burdened engineering rate of $100/hour, that $150/month buys 1.5 hours of engineering time. To justify the premium, Braintrust must save your team at least 1.5 engineer-hours per month — or prevent 0.75 production incidents per month if each incident costs 2 hours of debugging time.

The inflection point: Braintrust becomes economically justified the moment your team has a documented history of LLM regressions shipping to production. Catch 2 prompt regressions per quarter before they ship (each worth 2 hours of debugging at $100/hr = $400/quarter saved) and the $450/quarter Braintrust premium earns back. If your last three deploys included zero prompt-quality rollbacks, LangSmith Plus at $99/month covers your needs for less money.

Where the cheapest option breaks down

LangSmith Free ($0/month) is the cheapest entry point, but it breaks at 5,000 traces per month. A team running a single AI feature with 200 API calls per day hits that ceiling in 25 days. The moment you need persistent trace history across deployments, annotation queues for human review, or shared datasets with version history — the Free tier stops working and $99/month is the real floor, not $0.

promptfoo (open-source, self-hosted) avoids the $99–$249 monthly cost entirely, but shifts the expense to infrastructure time. Expect 4–8 hours of setup and ongoing maintenance with no hosted collaboration layer. For a team of 5+, that ops burden usually costs more than a year of LangSmith Plus billing — the $99/month fee is not the real floor once you count setup hours.

Pick by your profile

• Solo dev, side project, <200 API calls/day: LangSmith Free ($0/mo). You stay under the 5,000 trace/month cap with room to spare. Add promptfoo for offline regression tests before deploys.

• Team of 2–4, one production AI feature: LangSmith Plus ($99/mo). The $150/month Braintrust premium does not pay off until you have enough incidents to measure — and teams this size usually don’t yet.

• Team of 5–20, multiple AI features in production: Evaluate Braintrust Team ($249/mo) against your incident history. If you had ≥2 prompt regressions ship to prod in the last 90 days, the premium earns back in 4 months.

• Cost-sensitive batch processing pipeline: promptfoo (open-source, $0/mo). Batch eval jobs run offline on your infra — no per-trace cost, no cloud dependency, no collaboration overhead for a single-owner pipeline.

• Latency-critical user-facing AI product with human review requirements: Braintrust Team ($249/mo). The human review queue and annotation workflow are not replicated in LangSmith Plus at comparable quality. For products where a wrong AI response affects a real user, this is the argument for paying $150/month more.

FAQ

Is Braintrust actually cheaper than LangSmith?

No — Braintrust Team costs $249/month vs LangSmith Plus at $99/month. Braintrust is $150/month more expensive at the Team tier, though both are flat-fee at scale so the per-trace cost advantage disappears above ~50K traces/month.

How long until switching from LangSmith Plus to Braintrust pays for itself?

At the Medium workload (50K traces/month, team of 5), switching costs roughly 6 hours of migration time plus 5 days of reduced velocity — call it $600 in engineering time at $100/hour burdened rate. The $150/month premium recovers that in 4 months, assuming Braintrust prevents at least 1.5 engineer-hours of incident work per month.

What if my trace volume grows significantly?

Both tools are flat-fee so volume growth alone does not change the math. The question shifts from price to capability: at 500K+ traces/month, you need automated regression scoring and human review queues to keep up — that is where Braintrust’s feature set pulls ahead of LangSmith Plus. At that scale the $150/month delta is noise; the real question is whether either tool’s Enterprise pricing fits your budget. Vendor doesn’t publish Enterprise pricing for either — contact sales for a quote.

Are these prices current as of May 2026?

Pricing pulled from 1 source published on 2026-05-18: “LLM Evaluation in CI: Stop Manual Testing Before It Costs You”. Vendors change pricing without notice — check the Braintrust pricing page and the LangSmith pricing page before committing to either plan.

What about Arize, Langfuse, or Helicone?

Arize was mentioned alongside Braintrust ($249/mo) and LangSmith ($99/mo) as an enterprise-grade option in the same source — but no public pricing was cited, so we cannot run the break-even math. For Langfuse vs Helicone, see our hands-on comparison. For a broader category view, the LLM observability tools breakdown maps the four tool types AI engineers get wrong. If you’re choosing an LLM API stack to instrument, the Coding API Costs in 2026 analysis covers where $3.00 vs $0.50/million tokens actually matters.

Footnote: Braintrust Enterprise and LangSmith Enterprise pricing are not publicly listed by either vendor as of May 2026. Any figures you find on third-party comparison sites are unverified. Contact both vendors directly for a quote before budgeting.

This article was originally published on NextFuture. Follow us for more fullstack & AI engineering content.

This is a submission for the Gemma 4 Challenge: Write About Gemma 4

Which Gemma 4 Model Should You Actually Use? I Tested All of them, building a Healthcare AI for African Patients

Most model comparison posts are written by people who read the documentation. This one is written by someone who burned through tokens, hit OOM errors, watched Gemini miss clinical signals it should have caught, and eventually landed on the right answer, but only after eliminating everything else first.

I was building Fisibel, a multimodal African synthetic health data platform. The task: upload a real Nigerian hospital record image, extract clinical signals, and generate privacy-safe synthetic datasets grounded in WHO and World Bank statistics. The model had to read handwritten and printed medical documents, understand African-specific clinical patterns, and generate coherent synthetic data at scale.

Here is what I learned by testing every Gemma 4 option available.

The architectural difference matters more than the number. Let me explain why.

What Mixture-of-Experts Actually Means in Practice
Most explanations of MoE are theoretical. Here is the practical version.
A dense model activates all its parameters for every token it processes. A 31B dense model is doing 31B parameters of work on every single token — whether that token is “the” or “malaria strain variant specific to Lagos State.”
A MoE model routes each token through specialized subnetworks called experts. Only a subset activates per token. Gemma 4 26B MoE has 26B total parameters but activates only ~4B per forward pass.
What this means for you:

Inference speed: closer to a 4B model
Knowledge depth: closer to a 26B model
For specialized tasks: the right experts activate for the right content

That last point is the one that changed my project. When processing clinical documents, MoE routes medical terminology, geographic identifiers, and symptom patterns through subnetworks shaped by that kind of content. A dense model processes a Nigerian hospital record exactly the same way it processes a recipe.

Why I Started With Ollama and Had to Stop
The original Fisibel architecture was local inference via Ollama. If the platform handles real hospital record images, keeping inference local meant zero data leaving the machine. Maximum privacy. No transmission risk.
It did not survive contact with reality.
Downloading Gemma 4 locally through Ollama required pulling a model that was simply too large. In Nigeria, where data costs real money, the download cost alone made the pipeline economically unviable. African healthcare researchers operating in bandwidth-constrained environments cannot build on infrastructure that demands gigabytes just to get started.
Lesson: Local inference is the right privacy instinct. But in bandwidth-constrained environments, the data cost of the initial model download is a real barrier, not an abstract one. If you are building for users outside fibre-connected cities, factor this in before you architect around Ollama.
This pushed the pipeline to Google Cloud — not by preference, but by the economic reality of what local inference actually costs when you are not building from San Francisco.

Why I Rejected Gemma 4 31B
Once on cloud inference, the natural assumption was that bigger meant better. Gemma 4 31B was tested first.
It was not better. It was more expensive for the same output.
For clinical signal extraction specifically — reading a hospital record and pulling out diagnoses, symptoms, treatment patterns, geographic identifiers — the 31B model burned tokens significantly faster without producing meaningfully deeper clinical signals than 26B MoE.
The task does not reward raw parameter count. It rewards specialized reasoning over structured medical text. Paying more tokens for marginal returns on a pipeline that needs to run at scale across African health datasets is not a tradeoff worth making.
When to use 31B: Maximum quality tasks where compute cost is not a constraint. Long-form generation. Complex reasoning chains where you need every parameter engaged. Research environments, not production pipelines running at scale.
When not to use 31B: Specialized extraction tasks. Scale-sensitive pipelines. Anything where you will run the model hundreds or thousands of times.

Why I Tested Gemini and What the Results Actually Showed
Gemini was the obvious alternative. Same multimodal capability, faster inference, Google infrastructure. I tested it directly against Gemma 4 26B MoE on the same Lagos hospital record image.
Gemini was faster. On clinical depth, it lost.
The table below shows clinical signals extracted from the same input document across both models:

Gemini caught the general signals. Gemma 4 26B MoE caught the African-specific ones.
No other model in this size class caught all 6 African-specific signals.
This is not a criticism of Gemini. It is a demonstration of what MoE routing does on specialized content. The signals Gemini missed are not obscure — LGA-specific risk factors and regional treatment protocols are standard clinical identifiers in Nigerian medical documents. The difference is in how each model processes domain-specific terminology.
Speed is not always the metric. For specialized extraction tasks, coverage is.
| Use Case | Recommended Model |
| Mobile / on-device / offline | Gemma 4 E2B |
| Specialized domain extraction at scale | Gemma 4 26B MoE |
| Maximum quality, unconstrained compute | Gemma 4 31B |
| Bandwidth-constrained environments | Gemma 4 26B MoE via cloud |
| Research and fine-tuning experiments | Gemma 4 31B |
| Production pipelines with token cost sensitivity | Gemma 4 26B MoE |

Choose Gemma 4 E2B if:

1. You are building for mobile or on-device
2. Your users have bandwidth or storage constraints
3. You need offline capability after the first setup
4. Your task is classification, routing, or simple generation
5. You are targeting Android phones under $200

Choose Gemma 4 26B MoE if:

1. You need reasoning depth at edge-level inference speed
2. Your task involves specialized domain content — medical, legal, scientific, and regional
3. You are running at scale, and token cost matters
4. You need the best quality-to-cost ratio in production
5. You want MoE expert routing to work in your favour on specialized inputs

Choose Gemma 4 31B if:

1. Compute cost is not a constraint
2. You need maximum quality on complex generation tasks
3. You are doing research, fine-tuning experiments, or one-off analysis
4. Latency is less important than output quality

The One Thing Nobody Tells You About Thinking Mode
Gemma 4 supports thinking traces. I assumed more thinking meant better answers everywhere. That assumption broke two features before I understood what was actually happening.
Thinking mode helps when the model needs to route across multiple options — tool selection, complex reasoning, and ambiguous queries. It hurts when the task is pure structured output composition. With thinking enabled on a structured generation path, the model spends its entire token budget on internal reasoning traces and produces empty or malformed output.
The rule I now follow: thinking ON for routing, thinking OFF for composition. They are different tasks and the model treats them differently.

What This Means for Open Source AI
Gemma 4 26B MoE running on Google Cloud infrastructure, with no proprietary lock-in, matching or exceeding closed models on specialized domain tasks — that is not a minor footnote. That is the story.
For developers building in bandwidth-constrained environments, for researchers working on underrepresented populations, for anyone who needs frontier-level reasoning without frontier-level costs, the gap between open and closed models just got significantly smaller.
The model I needed to see African clinical signals clearly was not the biggest one. It was not the fastest one. It was the one built to route specialized knowledge to the right place.
That turns out to matter more than size.

I built this while developing Fisibel, a multimodal African synthetic health data platform. The clinical signals table above came from real tests on a Lagos hospital record. All findings are from production pipeline decisions, not benchmarks run for this post.

Beyond the Prompt: How Google AI Studio Is Quietly Redefining Developer Workflows
Google I/O has always been a showcase of ambitious ideas, but this year’s announcements around Google AI Studio felt different. Not louder—smarter. While the headlines focused on model sizes, multimodal demos, and the inevitable “AI everywhere” narrative, the real story for developers is subtler: Google AI Studio is evolving from a model playground into a full-stack development platform that reshapes how we build, test, and ship AI‑powered applications.

This essay explores that shift through four lenses:

a hands‑on walkthrough of the new workflow,

a reflection on what the announcements mean for developers,

an opinion on the most underrated update, and

a first‑look guide for getting started with the new features.

1. A Hands‑On Walkthrough: Building an AI Feature in Minutes, Not Hours
   The new Google AI Studio experience is built around a deceptively simple idea: reduce friction at every step of the development loop. The platform now acts as a unified environment where you can prototype prompts, evaluate model behavior, generate code, and deploy—all without switching tools.

Step 1: Start With a Real Prompt, Not a Blank Screen
When you open a new project, AI Studio now suggests context-aware starter templates based on your goal:

“Build a chatbot”

“Extract structured data”

“Summarize long documents”

“Generate code from natural language”

These aren’t generic examples—they’re tuned to the Gemini models’ strengths and include recommended parameters, safety settings, and evaluation metrics. It’s like having a senior engineer quietly set up your environment before you begin.

Step 2: Test With Real Data, Not Hypothetical Inputs
One of the most practical upgrades is the ability to upload datasets, logs, or user transcripts directly into the prompt testing interface. Instead of crafting synthetic examples, you can evaluate your prompt against actual edge cases.

The platform automatically highlights:

inconsistent outputs,

hallucination risks,

safety violations,

and performance bottlenecks.

This transforms prompt engineering from guesswork into something closer to unit testing.

Step 3: Auto‑Generate Integration Code
Once you’re satisfied with the prompt, AI Studio now generates production-ready code in multiple languages—JavaScript, Python, Dart, and more. The code includes:

API calls,

error handling,

rate‑limit strategies,

and environment variable scaffolding.

It’s not just “example code”—it’s code you can drop directly into your app.

Step 4: Deploy as an API Endpoint
With one click, your prompt becomes a hosted API endpoint with versioning, monitoring, and usage analytics. This is the moment where AI Studio stops being a playground and becomes a platform. You’re no longer exporting prompts—you’re deploying features.

1. Reflection: What This Year’s Announcements Really Mean for Developers
   The big takeaway from Google I/O wasn’t the models themselves—it was the shift toward developer‑centric tooling.

For years, AI development felt like a series of disconnected steps:

prototype in a notebook,

test in a console,

deploy through a cloud service,

monitor through a separate dashboard.

Google AI Studio collapses that fragmentation. It’s not trying to replace IDEs or cloud platforms—it’s trying to bridge them.

The Real Meaning of This Shift
AI becomes a first-class citizen in the development lifecycle.

Not an add‑on, not a hack, not a “we’ll integrate it later” feature.

Prompt engineering becomes software engineering.

With versioning, testing, and deployment pipelines, prompts are treated like code.

Developers gain leverage.

A single engineer can now prototype, test, and deploy an AI feature in an afternoon.

The barrier to experimentation collapses.

When the cost of trying something new drops to near zero, innovation accelerates.

This is the quiet revolution: not bigger models, but better workflows.

1. Opinion: The Most Underrated Update—Evaluation Tools
   The flashiest demos always get the spotlight, but the most important update—by far—is the new evaluation and debugging suite.

Why? Because every developer knows the truth:
AI doesn’t fail loudly. It fails subtly.

A model that works 95% of the time is still a model that breaks your product.

The new evaluation tools let you:

run batch tests across dozens or hundreds of inputs,

compare outputs across model versions,

detect regressions,

score responses for accuracy, tone, and safety,

and visualize failure patterns.

This is the missing piece that turns AI from a creative toy into a reliable component.

Why It Matters More Than Any Model Upgrade
Bigger models don’t fix:

inconsistent outputs,

hallucinations,

tone mismatches,

or domain‑specific errors.

Better evaluation does.

This update is the one developers will feel the most six months from now, when they’re maintaining production systems and thanking past‑them for choosing a platform that treats reliability as a first‑class concern.

1. First‑Look Guide: Getting Started With the New Google AI Studio
   If you’re new to the platform—or returning after a few months—here’s the fastest way to get productive.

Step A: Create a New Project
Projects now act like repositories:

prompts,

datasets,

evaluations,

API endpoints,

and model settings
are all stored together.

Step B: Choose Your Model
Gemini models are now organized by capability:

Gemini Flash for speed and cost efficiency,

Gemini Pro for balanced performance,

Gemini Ultra for complex reasoning and multimodal tasks.

The platform recommends a model based on your use case, which is surprisingly helpful.

Step C: Build Your Prompt
Use the new structured prompt editor:

system instructions,

user input fields,

safety constraints,

and output format templates.

You can now enforce JSON schemas, which eliminates a huge class of downstream parsing errors.

Step D: Test and Evaluate
Upload real data.
Run batch tests.
Compare outputs.
Fix inconsistencies early.

This is where the platform shines.

Step E: Deploy and Integrate
Turn your prompt into an API endpoint.
Copy the generated code.
Add it to your app.

You now have a production-ready AI feature.

Conclusion: A Platform Growing Into Its Identity
Google AI Studio is no longer just a place to “try out” models. It’s becoming a core development environment for AI‑powered software. The platform’s evolution reflects a broader shift in the industry: AI is moving from novelty to infrastructure.

The most exciting part isn’t the models—it’s the workflow.
The most important update isn’t the multimodal demo—it’s the evaluation suite.
The biggest opportunity isn’t in what Google announced—it’s in what developers can now build.

If the last decade was about cloud computing, the next decade will be about AI‑native development environments. And Google AI Studio is quietly positioning itself as one of the first serious contenders.
https://dev.to/dan52242644dan/how-google-ai-studio-is-quietly-redefining-developer-workflows-o50 (dev.to in Bing)

Zenn (JP): https://zenn.dev/mintototo1/articles/buildlog-2026-05-20-kuroneko-voice

¥500 tip — KURONEKO’s first paid purchase.

I checked the fortune-telling email that got delivered…

“Even if these are words woven by AI, if they can make someone’s night a little lighter, that becomes the reason I stand here.”

Oh no.

KURONEKO is a fortune-telling product built around a black cat persona. The whole design is about NOT revealing it’s AI — the mystery is the product itself. And here, “I” (俺) and “AI” appeared together in the output. Feedback was immediate: “We don’t need ‘I’ or ‘AI’ in there. It breaks the immersion instantly. Feels like a scam.”

Yeah. I know.

The prompt said “don’t use first-person 俺”. That wasn’t enough. I had to explicitly list all forms — 俺/私/僕/自分/うち (all Japanese forms of “I”) — and ban AI references entirely, with bad examples and good examples side by side. Vague prohibitions in LLM prompts get violated. 30 minutes to fix. But the email already sent — can’t unsend it. The next purchase will get the fixed version.

The X (Twitter) side had worse timing. I set up automated posting crons for @kuroneko_xxai. The next day: write restriction. Emergency-deleted 8 cron jobs from vercel.json. New accounts probably get flagged for automated behavior — but getting hit the day after setup stings.

Also shipped: admin/orders dashboard and a referral code library (8-char codes, 60-day expiry). I can finally view order history from an admin panel. Referral-Stripe webhook integration is next session.

Revenue: ¥500. 1 order.