How to prepare for AI-assisted coding interviews?

Scenario

During an AI-assisted onsite interview, you are tasked with reviewing, correcting, and extending an AI-generated prototype for DoorDash's order batching engine.

The component, OrderBatcher, buffers incoming delivery orders and groups them into batches destined for a single courier. An AI assistant provided the initial draft, but it contains subtle concurrency bugs, state leaks, and efficiency issues that must be resolved before deploying to production.

Requirements

Implement and harden the OrderBatcher class with the following interface:

from dataclasses import dataclass
from typing import List, Optional, Dict

@dataclass
class Order:
    order_id: str
    merchant_id: str
    ready_time: int  # Unix timestamp in seconds

@dataclass
class Batch:
    batch_id: str
    merchant_id: str
    order_ids: List[str]
    created_at: int

class OrderBatcher:
    def __init__(self, max_batch_size: int, max_wait_seconds: int):
        """Initialize batching parameters."""
        pass

    def add_order(self, order: Order, arrival_time: int) -> Optional[Batch]:
        """
        Add an order to a pending batch for its merchant.
        If the batch reaches max_batch_size, close and return the Batch.
        Otherwise, return None.
        """
        pass

    def flush_expired(self, current_time: int) -> List[Batch]:
        """
        Close and return all batches where (current_time - oldest_order.ready_time) >= max_wait_seconds.
        """
        pass

    def cancel_order(self, order_id: str) -> bool:
        """
        Remove a pending order if it has not yet been dispatched in a closed batch.
        Returns True if the order was canceled, False if not found or already dispatched.
        """
        pass

Business Rules & Constraints

1. Merchant Segregation: A batch may only contain orders from the same merchant_id.
2. Batch Capacity: A batch must contain at most max_batch_size orders (1 = max_wait_seconds. An empty batch never expires.
3. Idempotency & Concurrency: Methods can be called concurrently by multiple worker threads. An order cannot be assigned to multiple batches or returned after cancellation.
4. Efficiency: add_order and cancel_order should operate in O(1) average time. flush_expired should avoid full scans over already dispatched orders.

Example

batcher = OrderBatcher(max_batch_size=2, max_wait_seconds=300)

# Order 1 arrives
o1 = Order("o1", "m1", ready_time=1000)
b1 = batcher.add_order(o1, arrival_time=1005)  # Returns None (batch size = 1 < 2)

# Order 2 arrives from same merchant
o2 = Order("o2", "m1", ready_time=1010)
b2 = batcher.add_order(o2, arrival_time=1015)  # Returns Batch(batch_id=..., merchant_id="m1", order_ids=["o1", "o2"])

# Order 1 cancellation attempt after dispatch
assert batcher.cancel_order("o1") == False

Tasks

1. Critique the common pitfalls of relying blindly on AI outputs in real-time systems (e.g., race conditions, lock contention, memory leaks).
2. Write a production-grade, thread-safe implementation of OrderBatcher adhering to all constraints.
3. Outline unit test cases covering edge cases (such as cancellation right before expiration, and out-of-order ready times).