Microsoft: Phi 4

Review this Python function for edge cases and suggest improvements: def calculate_discount(price, discount_percent): return price - (price * discount_percent / 100)

The function has several edge cases to handle: 1. **Negative values**: No validation for negative price or discount_percent 2. **Discount > 100%**: Could return negative final price 3. **Type safety**: No checks for non-numeric inputs Improved version: ```python def calculate_discount(price: float, discount_percent: float) -> float: if price < 0: raise ValueError("Price cannot be negative") if not 0 <= discount_percent <= 100: raise ValueError("Discount must be between 0 and 100") return price * (1 - discount_percent / 100) ``` The refactored calculation `price * (1 - discount_percent / 100)` is also more numerically stable for floating-point arithmetic.

Phi 4's 14B parameter size delivers solid code review with practical edge-case identification. The 16K context window handles this single-function review easily, though larger codebases would require chunking. At $0.07/$0.14 per Mtok, this is cost-effective for iterative code review workflows where you need multiple passes.

Explain the difference between TCP and UDP to a junior developer who understands basic networking but hasn't worked with protocols directly.

Think of TCP and UDP as two different shipping services: **TCP (Transmission Control Protocol)** is like certified mail with tracking. It guarantees your package arrives, in order, and confirms delivery. If something goes wrong, it resends. This reliability comes with overhead—handshakes, acknowledgments, retransmissions. Use TCP for web browsing, file transfers, emails—anything where accuracy matters more than speed. **UDP (User Datagram Protocol)** is like throwing postcards in the mail. Fast, lightweight, no guarantees. Packets might arrive out of order, get lost, or duplicate. But there's minimal overhead. Use UDP for live video, gaming, DNS lookups—anything where speed matters and you can tolerate occasional data loss. Rule of thumb: Need reliability? TCP. Need speed and can handle imperfection? UDP.

This example shows Phi 4's ability to adapt technical explanations to audience level—the shipping analogy makes protocols concrete without oversimplifying. The model balances accessibility with technical accuracy. However, at 16K tokens, extended back-and-forth tutoring sessions may hit context limits faster than larger-window alternatives.

Generate a SQL query to find customers who made purchases in Q1 2024 but not in Q2 2024, including their total Q1 spend. Tables: customers (id, name), orders (id, customer_id, order_date, amount).

```sql SELECT c.id, c.name, SUM(o.amount) AS q1_total_spend FROM customers c INNER JOIN orders o ON c.id = o.customer_id WHERE o.order_date >= '2024-01-01' AND o.order_date < '2024-04-01' AND c.id NOT IN ( SELECT DISTINCT customer_id FROM orders WHERE order_date >= '2024-04-01' AND order_date < '2024-07-01' ) GROUP BY c.id, c.name ORDER BY q1_total_spend DESC; ``` This uses a subquery to exclude Q2 purchasers. For large datasets, consider a LEFT JOIN with NULL check instead of NOT IN for better performance.

Phi 4 generates syntactically correct SQL with appropriate date filtering and aggregation. The performance note shows awareness of query optimization. The 16K context window accommodates schema descriptions and multi-table queries comfortably, though complex data warehouse schemas with dozens of tables would strain it. Pricing makes this viable for automated query generation in internal tools.

Why Phi 4 works for rapid iteration on tight budgets

A 4-person product team building an MVP chatbot needs to test 20 prompt variations daily without burning through their $200/month AI budget. Phi 4 at $0.07/$0.14 per Mtok is roughly 10x cheaper than frontier models, which means they can run 500k input tokens and 250k output tokens for under $50. The 16k context window handles most conversational threads and product docs without chunking. The trade-off: you'll hit quality ceilings on complex reasoning or nuanced tone—if user testing shows the bot missing intent more than 15% of the time, budget up to GPT-4o mini. For prototyping where speed and cost matter more than perfection, Phi 4 lets you fail fast and iterate without the invoice anxiety.

When Phi 4 handles repetitive support queries at scale

A 30-person SaaS company fields 200 internal Slack questions daily about PTO policy, expense rules, and onboarding steps. Phi 4 can ingest the 12k-token employee handbook, match questions to sections, and draft answers in under 2 seconds at $0.07 input per million tokens. Over a month, that's roughly 6M input tokens ($0.42) and 3M output tokens ($0.42)—under a dollar for thousands of responses. The 16k window fits the full handbook plus conversation history, so answers stay contextual across follow-ups. The boundary: if questions require interpreting ambiguous policy edge cases or synthesizing across multiple documents, accuracy drops and you'll need a larger model. For straightforward lookup-and-paraphrase tasks where the answer exists in a single doc, Phi 4 delivers at a price that makes automation a no-brainer.

Phi 4 for real-time comment filtering on community platforms

A 10-person ed-tech startup runs a student forum with 5,000 comments posted daily and needs to flag spam, profanity, and off-topic posts before they go live. Phi 4's sub-$0.10/Mtok combined pricing means scanning 500 tokens per comment (2.5M tokens/day input, 500k tokens/day output for verdicts) costs around $0.25 daily or $7.50/month. The 16k context window lets you include community guidelines and recent thread context in each moderation call. The catch: Phi 4 will miss subtle harassment patterns or sarcasm that frontier models catch—if your false-negative rate climbs above 5%, you need a smarter model or human review layer. For high-volume, low-stakes filtering where speed and cost are the constraints, Phi 4 keeps the workflow moving without the per-call sticker shock.