OpenAI: GPT-5.2

Review this Python function for edge cases and suggest improvements. Focus on type safety and error handling: def calculate_discount(price, percent): return price - (price * percent / 100)

This function has several edge cases worth addressing: 1. **Negative inputs**: Both `price` and `percent` could be negative, producing unexpected results. Add validation. 2. **Type coercion**: No type checking means strings or None could cause runtime errors. 3. **Percent > 100**: A 150% discount would return a negative price. Improved version: ```python def calculate_discount(price: float, percent: float) -> float: if price < 0: raise ValueError("Price cannot be negative") if not 0 <= percent <= 100: raise ValueError("Percent must be between 0 and 100") return price * (1 - percent / 100) ``` This adds type hints, validates ranges, and uses a more numerically stable calculation.

With a 400K token context window, GPT-5.2 can review entire codebases in one pass, catching edge cases across multiple files. This example shows its systematic approach to defensive programming. The model balances thoroughness with brevity, though at $14/Mtok output, lengthy code reviews add up quickly for high-volume teams.

I have a 47-page technical specification PDF for a new API. Extract the authentication flow, rate limits, and webhook payload schemas into a structured summary I can share with my engineering team.

**Authentication Flow** OAuth 2.0 with PKCE. Clients request authorization at `/oauth/authorize`, exchange code for access token at `/oauth/token`. Tokens expire after 1 hour; refresh tokens valid for 30 days. **Rate Limits** - Standard tier: 1000 requests/hour per API key - Premium tier: 10,000 requests/hour - Burst allowance: 50 requests/minute - Rate limit headers: `X-RateLimit-Remaining`, `X-RateLimit-Reset` **Webhook Payloads** ```json { "event": "order.completed", "timestamp": "ISO-8601", "data": { "order_id": "string", "status": "enum", "total": "decimal" } } ``` Supports: `order.completed`, `payment.failed`, `user.updated`. Signature verification via HMAC-SHA256 in `X-Webhook-Signature` header.

File upload support means GPT-5.2 can ingest long PDFs directly without preprocessing. This example demonstrates extraction accuracy across scattered sections of a spec document. The 400K context window handles even the longest technical documents, though multimodal processing adds latency compared to text-only requests.

Write a cold outreach email to a VP of Engineering at a Series B startup. We're selling observability tooling. Make it personalized but not creepy, and keep it under 100 words.

Subject: Quick question about your deployment pipeline Hi [Name], Saw your team recently crossed 50 engineers—congrats on the growth. That's usually when deployment visibility becomes a daily headache instead of a monthly one. We built [Product] to give eng leaders like you real-time insight into what's actually slowing down releases (spoiler: it's rarely the thing you think). Worth a 15-minute conversation? I can show you what three other Series B teams discovered in their first week. [Your name] P.S. — No demo unless you find the data interesting. Promise.

GPT-5.2 handles nuanced tone control well, balancing professionalism with approachability. This example shows its ability to write in a specific voice without generic sales language. The model avoids the overly formal or overly casual extremes common in earlier GPT versions, though it still requires explicit constraints to prevent verbosity.

When 400K context beats RAG for discovery workflows

A 12-person litigation support team needs to cross-reference depositions, contracts, and email threads spanning 300+ pages per case. GPT-5.2's 400K context window lets you load entire case files in a single prompt—no chunking, no vector search, no retrieval errors. At $1.75/Mtok input, a 350K-token case costs ~$0.61 to load once, then you run 20-30 queries against it for pennies each. The trade-off: output at $14/Mtok means verbose responses (5K+ tokens) push costs to $0.70+ per answer. If your team writes tight prompts and needs fewer than 40 queries per case, this beats building a RAG pipeline. Beyond that volume, switch to a cheaper model with external search.

Why vision + massive context works for batch labeling jobs

A 4-person data ops team labels medical imaging datasets—each batch is 80-120 scans with a 60-page protocol document. GPT-5.2 ingests the full protocol and all images in one call, so every label references the same grounding without re-uploading context. The 400K window holds ~100 high-res images plus instructions; at $1.75/Mtok input you're spending $2-3 per batch. Output cost ($14/Mtok) stings if you generate long explanations, but structured JSON labels (200-500 tokens per image) keep it under $1/batch. This works when consistency across a batch matters more than per-image speed. If you're labeling 500+ images daily, parallelize with a faster vision model instead.

When you pay $14/Mtok for a single high-stakes output

A 3-person executive team compiles a board deck from 15 department updates, 8 financial spreadsheets, and 40 pages of market research—due in 6 hours. GPT-5.2's 400K context loads everything at once: no manual stitching, no context loss between sections. Input cost is $2.50 for 200K tokens; the real spend is output—a 10K-token draft deck runs $0.14, but if you iterate 5 times with detailed feedback (30K tokens total), you're at $0.42. For a quarterly artifact that saves 12 hours of human synthesis, $3 total is a rounding error. This model makes sense when the task is infrequent, the stakes are high, and you'd otherwise pay a consultant $200/hour to do the same work.