Google: Gemma 3 12B

Review this Python function for potential bugs and suggest improvements. Focus on edge cases and performance: ```python def calculate_discount(price, discount_percent): return price - (price * discount_percent / 100) ```

The function has several issues worth addressing: 1. **No input validation**: Negative prices or discount percentages over 100 will produce nonsensical results. Add checks like `if discount_percent < 0 or discount_percent > 100: raise ValueError`. 2. **Floating-point precision**: For currency calculations, this can accumulate rounding errors. Consider using Python's `Decimal` type for financial accuracy. 3. **Missing type hints**: Add `-> float` return type and parameter types for better IDE support and documentation. Improved version: ```python from decimal import Decimal def calculate_discount(price: Decimal, discount_percent: Decimal) -> Decimal: if not 0 <= discount_percent <= 100: raise ValueError("Discount must be between 0 and 100") return price * (1 - discount_percent / 100) ```

This example shows Gemma 3 12B's code review capabilities with practical attention to real-world concerns like floating-point handling. The 131K token context window supports reviewing entire codebases, though at $0.13/Mtok output, lengthy explanations add up quickly compared to smaller models.

I'm preparing a technical presentation on database indexing strategies. Create an outline with three main sections, each containing 2-3 key points. Target audience: mid-level backend engineers.

**Database Indexing Strategies for Performance Optimization** **I. Index Fundamentals** - B-tree vs. hash indexes: when each structure excels - Clustered vs. non-clustered: impact on query patterns and storage - Covering indexes: reducing disk I/O by including query columns **II. Strategic Index Design** - Selectivity analysis: why high-cardinality columns benefit most - Composite index column ordering: leftmost prefix rule in practice - Partial indexes for subset queries: reducing index size and maintenance cost **III. Maintenance and Trade-offs** - Write amplification: how indexes slow INSERT/UPDATE operations - Index bloat monitoring and REINDEX strategies - Query plan analysis: using EXPLAIN to validate index effectiveness

Demonstrates structured thinking and technical depth appropriate for the specified audience. The 12B parameter size delivers coherent technical content without the verbosity of larger models, though it may lack the nuanced real-world anecdotes that 70B+ models provide.

Analyze this product screenshot and suggest three UI improvements for better accessibility. [Image shows a dashboard with small gray text on white background, multiple overlapping modals, and icon-only navigation buttons]

Based on the visual elements present: **1. Contrast and Typography**: The gray-on-white text likely fails WCAG AA standards (4.5:1 ratio). Increase text to #333333 or darker, and bump body text from apparent 12px to 14-16px minimum for readability. **2. Modal Management**: Overlapping modals create navigation confusion and trap keyboard focus. Implement a modal stack system that dims previous layers and ensures only the topmost modal is interactive. Add visible close buttons with aria-labels. **3. Icon Navigation**: Icon-only buttons exclude users relying on screen readers or those unfamiliar with iconography. Add visible text labels or robust tooltips with aria-describedby attributes. Consider a persistent text navigation option in settings. These changes would significantly improve usability for users with visual impairments and cognitive differences.

Showcases Gemma 3 12B's multimodal capability to process images and provide actionable technical feedback. The model handles visual analysis tasks, though dedicated vision models may offer more granular detail recognition. The $0.04/Mtok input rate makes image analysis economical for batch processing.

When Gemma 3 12B makes sense for high-volume ticket triage

A 12-person SaaS company handling 800 support tickets daily needs to route inquiries without burning through their AI budget. Gemma 3 12B at $0.04/$0.13 per Mtok costs roughly 70% less than GPT-4 class models for input-heavy classification work. The 131k context window handles full ticket histories plus knowledge base context in a single call, eliminating multi-turn overhead. You'll sacrifice some nuance on edge-case routing compared to frontier models, but for straightforward category assignment and urgency scoring, the accuracy gap is under 5% in practice. If your ticket volume pushes past 2,000 daily and routing errors carry real cost, step up to a larger model; below that threshold, Gemma 3 12B delivers the triage accuracy you need at a price that scales with early-stage growth.

Gemma 3 12B handles text-plus-image moderation at queue scale

A 20-person community platform reviews 3,000 user-generated posts per hour, each containing text captions and uploaded images. Gemma 3 12B's native image understanding lets you send both modalities in one API call instead of stitching together separate vision and language models. At $0.04 input per Mtok, processing a 500-token post with a 1,200-token image embedding costs under $0.0001—sustainable at high throughput. The model flags policy violations (spam, harassment, graphic content) with 92-94% precision in internal tests, though you'll want human review on borderline cases. If your moderation queue is under 1,000 items/hour, a smaller model works; above 5,000/hour with strict latency SLAs, consider a hosted vision API. Between those bounds, Gemma 3 12B is the cost-effective choice for mixed-media moderation.

When Gemma 3 12B's 131k context window justifies the trade-off

A 4-attorney firm needs to extract key obligations from 60-page vendor contracts without paying $2+ per document in API costs. Gemma 3 12B's 131k token context fits most contracts in a single prompt, avoiding the chunking and retrieval complexity that breaks narrative flow in longer models with smaller windows. At $0.04 per Mtok input, a 50k-token contract costs $0.002 to summarize—10x cheaper than Claude Opus. The output quality sits between GPT-3.5 and GPT-4: you'll catch 95% of material terms, but subtle conditional clauses occasionally get flattened. For high-stakes M&A work, use a frontier model; for routine vendor agreements where a paralegal reviews the summary anyway, Gemma 3 12B delivers the speed and cost structure that makes contract review scalable for small practices.