async def get_user_recommendations(
    user_id: int,
    limit: int = 10,
    exclude_seen: bool = True,
) -> list[RecommendationItem]:
    """
    Fetch ranked recommendations for a user.

    - Queries the recommendations table ordered by score DESC
    - If exclude_seen=True, LEFT JOIN seen_items and filter WHERE seen.id IS NULL
    - Returns at most `limit` items
    - Raises UserNotFoundError if user_id doesn't exist

    Use SQLAlchemy async session from context (self.session).
    """
    ...  # implement this

# Prompt: Make this test pass. Do not modify the test.

def test_rate_limiter():
    limiter = RateLimiter(requests_per_second=2)

    limiter.acquire()  # t=0, should succeed
    limiter.acquire()  # t=0, should succeed (2 per second)

    with pytest.raises(RateLimitExceeded):
        limiter.acquire()  # t=0, over limit

    time.sleep(1.0)
    limiter.acquire()  # t=1, should succeed again

    assert limiter.current_count() == 1

# Reasoning output (abbreviated):
# "Sort by start time first — O(n log n). Then iterate, merging when
# current.start <= last_merged.end. Edge cases: empty list, single interval."

def merge_intervals(intervals: list[list[int]]) -> list[list[int]]:
    if not intervals:
        return []

    intervals.sort(key=lambda x: x[0])
    merged = [intervals[0]]

    for current in intervals[1:]:
        last = merged[-1]
        if current[0] <= last[1]:
            last[1] = max(last[1], current[1])
        else:
            merged.append(current)

    return merged

# Bad prompt (high token cost)
"Write a connection pool"
→ Generic pool, no backpressure, 3 follow-ups needed = 4,200 total tokens

# Medium prompt (moderate token cost)
"Write a connection pool that supports backpressure using semaphores"
→ Has backpressure, but no monitoring, 1 follow-up = 2,800 tokens

# Good prompt (low token cost)
"You are a senior Python engineer. Stack: asyncio, psycopg3, prometheus.
Implement AsyncConnectionPool that:
1. Maintains pool size between min_size and max_size
2. Blocks acquire() when pool exhausted (backpressure via Semaphore)
3. Emits prometheus metrics: pool_size, pool_waiters, connection_errors
4. Cleans up idle connections every 60 seconds

Here's the interface:
class AsyncConnectionPool:
    async def acquire(self) -> Connection: ...
    async def release(conn: Connection): ...
    def get_metrics(self) -> dict: ...

Implement the class."
→ Production-ready on first try = 1,200 tokens

# Complete prompt using all 7 patterns

You are a senior TypeScript/Node.js engineer. Stack: Node.js 20, TypeScript 5.3, EventEmitter2.
Constraints:
- All event handlers are async
- No global state — handlers receive context object
- Event names use dot notation (user.created, order.shipped)

INTERFACE FIRST:
Implement this event router class:

class EventRouter {
  register(pattern: string, handler: EventHandler): void
  emit(event: string, payload: unknown): Promise<void[]>
}

interface EventHandler {
  (context: RouterContext, payload: unknown): Promise<void>
}

FAILING TEST (make this pass):

describe("EventRouter", () => {
  it("should route events by pattern", async () => {
    const router = new EventRouter();
    const calls: string[] = [];

    router.register("user.*", async (ctx, payload) => {
      calls.push("user-handler");
    });

    router.register("user.created", async (ctx, payload) => {
      calls.push("specific-handler");
    });

    await router.emit("user.created", { id: 123 });
    expect(calls).toEqual(["user-handler", "specific-handler"]); // both run
  });
});

CHAIN OF THOUGHT:
Before writing code, explain:
1. How you'll match "user.*" against "user.created"
2. How you'll ensure both handlers run without one blocking the other
3. What error cases you'll handle

NEGATIVE CONSTRAINTS:
Do NOT:
- Use global EventEmitter — pass as constructor argument
- Return early if one handler fails — all handlers should run
- Use sync callbacks — all handlers must be async
- Use lodash or minimatch — implement pattern matching directly

GO:

# ❌ Too vague — wastes tokens
"Write a database query function"

# ✅ Specific — saves tokens
"Write a PostgreSQL parameterized query function that:
- Takes a query string and list of parameters
- Returns typed results (generic <T>)
- Throws QueryError (not generic Error) on failure
- Includes connection pooling via pgx"

# ❌ Unclear constraint
"Don't use bad patterns"

# ✅ Clear constraint
"Do NOT: use string.split() for CSV parsing (breaks on quoted fields),
use synchronous I/O, return untyped results"

# ❌ Missing context
"Generate an auth middleware"

# ✅ With context
"You are building Express.js middleware for JWT auth.
We use RS256 keys stored in environment as base64.
Attach the decoded token to req.user. Return 401 with message 'Invalid token' on failure."