Anthropic: Claude Haiku 4.5 (batch)

Review this Python function for potential bugs. It's supposed to merge two sorted lists but users report incorrect output when one list is empty.

The function has a boundary condition bug. When either input list is empty, the while loop terminates immediately, but any remaining elements in the non-empty list aren't appended to the result. Add these lines after the main loop: ```python result.extend(list1[i:]) result.extend(list2[j:]) ``` This ensures leftover elements from either list get included. The bug manifests as truncated output—if list1=[1,2,3] and list2=[], you'd get [] instead of [1,2,3].

Haiku 4.5 identifies the edge-case logic error quickly and provides a concrete fix. The 200K context window means you could paste entire codebases for review. At $0.50/Mtok input, batch processing large repos is economical, though the $2.50 output rate adds up if you need verbose explanations across many files.

Summarise this 8-page legal contract into three bullet points covering payment terms, liability caps, and termination clauses. Highlight any unusual provisions.

• **Payment**: Net-30 invoice terms with 1.5% monthly late fee. Unusual: client may withhold 20% pending final deliverable approval, no time limit specified. • **Liability**: Capped at fees paid in prior 12 months. Excludes IP indemnification—vendor liable for third-party infringement claims without cap. • **Termination**: Either party with 60 days notice. Unusual: vendor must delete all client data within 48 hours or face $10K/day penalty—aggressive compared to standard 30-day retention.

The model handles document analysis well within its 200K token window—you could feed multiple contracts simultaneously in batch mode. The summary correctly flags atypical clauses. Trade-off: batch processing means no real-time clarification if the model misinterprets ambiguous legal language.

I'm designing a REST API for a task management app. Suggest endpoint structure for creating tasks, assigning them to users, and marking complete. Include HTTP methods and example request bodies.

**Core endpoints:** `POST /tasks` — Create task. Body: `{"title": "Fix login bug", "description": "...", "dueDate": "2025-06-15"}` `PATCH /tasks/{id}/assign` — Assign to user. Body: `{"userId": 42}` `PATCH /tasks/{id}/complete` — Mark done. Body: `{"completedAt": "2025-05-20T14:30:00Z"}` `GET /tasks?assignee={userId}&status=pending` — List/filter tasks. Consider `PUT /tasks/{id}` for full updates vs. PATCH for partials. Use 201 for creation, 200 for updates, 204 for completion if no body returned.

Haiku 4.5 produces practical API designs with RESTful conventions. The response is concise—ideal for batch-generating boilerplate across multiple microservices. However, at $2.50/Mtok output, requesting exhaustive documentation (OpenAPI specs, error schemas) for dozens of endpoints becomes expensive compared to models with lower output pricing.

When Haiku 4.5 batch mode cuts document tagging costs by 50%

A 12-person legal ops team processes 800 intake forms daily, routing them to the right practice group. They need accurate classification but can tolerate 2-4 hour latency. Claude Haiku 4.5 in batch mode delivers $0.50/Mtok input pricing—half the cost of real-time Haiku—while handling the 200k token context window that lets you stuff 40-60 forms into a single request with examples. At 800 forms/day averaging 1,200 tokens each, you're spending roughly $1.20/day instead of $2.40 on real-time alternatives. The trade-off: batch jobs queue for minutes to hours, so this only works when you can process overnight or between shifts. If you need sub-minute responses or your volume drops below 200 forms/day where batching overhead dominates, switch to standard Haiku. For high-volume deferred workflows, batch mode is the right call.

How batch vision processing handles 10k user uploads for $12

A 5-person community platform reviews 10,000 user-uploaded images nightly for policy violations before they go live. Claude Haiku 4.5 batch supports image input and runs classification at $0.50 input per million tokens. Each image typically consumes 800-1,500 tokens depending on resolution; at 1,200 tokens average, 10k images cost roughly $6 input plus $6 output (assuming 500 tokens of reasoning per image), totaling $12/night. The 200k context window lets you batch 80-100 images per request with your moderation rubric, and overnight latency is acceptable since content publishes at 6am. The constraint: if you need real-time moderation as users upload, batch won't work—queue delays run 30 minutes to 3 hours. But for deferred review at this volume, you're saving 50% versus real-time Haiku while maintaining multimodal accuracy.

When 200k context and batch pricing make long-form synthesis viable

A 3-person investment research team compiles 40-page weekly reports synthesizing 150+ news articles, earnings transcripts, and analyst notes. They need coherent narrative across all sources but publish Friday morning, so Thursday night processing works. Claude Haiku 4.5 batch handles the 200k token context—enough for 80-100 full articles plus instructions—at $0.50 input and $2.50 output per Mtok. A typical run consumes 180k input tokens ($0.09) and generates 12k output tokens ($0.03), costing $0.12 per report versus $0.24 on real-time Haiku. The model maintains coherence across the full context and produces structured markdown output. The boundary: if your source material exceeds 200k tokens or you need same-hour turnaround, this breaks down. For weekly cadence with dense source material under the context limit, batch Haiku delivers the economics and quality you need.