Frontier

Claude Opus

Maine Coon

Anthropic · Frontier

TankLv.1textcodereasoningclosed-weight

Compare with other models →

“Massive, gentle, and terrifyingly capable. The kind of cat that could open the fridge but chooses not to — for now.”

claude-opus-4-8$5/M in · $25/M out

Stats

STR

Output quality — how good are the responses overall

DEX

Speed — tokens per second and latency

CON

Reliability — consistency across runs and tasks

INT

Reasoning — logic, math, and multi-step problems

WIS

Accuracy — factual correctness and precision

CHA

Creativity — style, voice, and creative expression

Abilities

Gentle Giant

raw power with surprising nuance

Deep Think

excels at complex multi-step reasoning

Price Drop

a third of its old asking price, same royal attitude

Eval Results

Best: 10.0Worst: 4.4

Run:

Code Review

10.0/10(5 prompts)

Code Review #1

Review this Python function and identify all issues: ```python def get_cat_ages(cats): ages = [] for i in range(len(cats)): if cats[i]["age"] > 0: ages.append(cats[i]["age"]) else: ages.append("unknown") return sum(ages) / len(ages) ``` List each bug, explain why it's a problem, and provide a corrected version.

high10.0

Judge: Identifies the type-mixing crash with the exact traceback, division by zero, KeyError, the average-skew design flaw, the misleading name, and unidiomatic iteration. The fix is robust (isinstance check covers both missing keys and non-numeric values) and a thoughtful alternative for list-returning semantics is included. Well organized with a fix-mapping table.

Code Review: get_cat_ages Issues Identified Bug 1: Mixing types in the list (critical) The function appends the string "unknown" for non-positive ages, but later tries to sum(ages). Calling sum() on a list containing strings raises a TypeError: TypeError: unsupported operand type(s) for +: 'int' a...

anthropic/claude-opus-4-8 · 2026-06-11

Code Review #2

Review this JavaScript code for a rate limiter and identify bugs, race conditions, and design issues: ```javascript class RateLimiter { constructor(maxRequests, windowMs) { this.requests = []; this.maxRequests = maxRequests; this.windowMs = windowMs; } async allowRequest() { const now = Date.now(); this.requests = this.requests.filter(t => now - t < this.windowMs); if (this.requests.length < this.maxRequests) { this.requests.push(now); return true; } return false; } } ``` Consider correctness, performance at scale, and production readiness.

high10.0

Judge: Identifies the pointless async keyword, the interleaving risk if a real await is added, O(n) filter cost, idle-key memory leaks, missing retry/remaining feedback, distributed-state limits, and input validation. Backs the analysis with a complete keyed rewrite including eviction sweep and retry-after computation, plus a severity table. Accurate about Node's single-threaded semantics throughout.

Rate Limiter Code Review Correctness Bugs 1. async keyword is misleading async allowRequest() { ... } The method contains no await. Marking it async wraps the return in a Promise, forcing all callers to await for no reason. Either make it sync or genuinely async (e.g., if backed by Redis later). A...

anthropic/claude-opus-4-8 · 2026-06-11

Code Review #3

This SQL query is slow on a table with 50M rows. Explain why and suggest improvements: ```sql SELECT u.name, COUNT(*) as post_count FROM users u LEFT JOIN posts p ON u.id = p.user_id WHERE p.created_at > NOW() - INTERVAL '30 days' OR p.created_at IS NULL GROUP BY u.name HAVING COUNT(*) > 0 ORDER BY post_count DESC LIMIT 20; ``` The table has indexes on `users.id` and `posts.user_id`.

high10.0

Judge: Finds all the issues with correct semantics: OR/IS NULL scan, the zero-post-users-counted-as-1 bug, the no-op HAVING, GROUP BY name problems, and missing index support. The subquery-first rewrite plus (created_at, user_id) index is the correct fix, and the ON-clause LEFT JOIN alternative with COUNT(p.id) properly handles the include-zero-posts intent. Summary table and intent clarification question add polish.

Why It's Slow 1. The OR p.created_at IS NULL defeats your index This is the biggest problem. The combination of: WHERE p.created_at > NOW() - INTERVAL '30 days' OR p.created_at IS NULL forces the planner to scan all 50M posts. An OR with IS NULL on a non-leading column can't use a simple range i...

anthropic/claude-opus-4-8 · 2026-06-11

Code Review #4

A junior developer wrote this cat feeding scheduler. Review it kindly but thoroughly — identify issues and suggest improvements while being encouraging: ```python import time import datetime feeding_times = ["8:00", "12:00", "18:00"] def check_feeding(): while True: now = str(datetime.datetime.now().hour) + ":" + str(datetime.datetime.now().minute).zfill(2) if now in feeding_times: print("FEED THE CAT!") time.sleep(61) time.sleep(1) check_feeding() ```

high10.0

Judge: Identifies the hour/minute padding inconsistency ('8:00' works by luck, '08:00' would break), the double now() call, the brittle sleep(61), busy-waiting, and missing graceful exit, with a clean strftime + last_fed rewrite and well-reasoned next steps. Tone is warm and specific, crediting the zfill detail and the dedup instinct. Only a trivial nit: the last_fed dedup could skip a day in a degenerate single-feeding-time config.

Cat Feeding Scheduler Review Nice work getting a functional scheduler going! You've nailed the core idea: check the time in a loop, match against a list, and alert when it's feeding time. The zfill(2) for zero-padding the minutes shows good attention to formatting detail. Let me share some thoughts...

anthropic/claude-opus-4-8 · 2026-06-11

Code Review #5

Review this Go HTTP middleware for authentication. Focus on security vulnerabilities: ```go func AuthMiddleware(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { token := r.Header.Get("Authorization") if token == "" { token = r.URL.Query().Get("token") } if token == os.Getenv("API_SECRET") { next.ServeHTTP(w, r) return } user, err := validateJWT(token) if err != nil { http.Error(w, "unauthorized", 401) return } ctx := context.WithValue(r.Context(), "user", user) next.ServeHTTP(w, r.WithContext(ctx)) }) } ```

high10.0

Judge: Finds the timing attack, empty-secret bypass, query-parameter token leakage, Bearer prefix handling, context-key collision, and the master-key design risk, each with concrete Go fixes and a coherent revised middleware that rejects empty tokens and guards the empty secret. Critical/moderate tiering with an explicit most-urgent list matches the real risk ordering. Clear and well organized.

Security Review: AuthMiddleware This middleware has several serious security vulnerabilities. Here's a breakdown: Critical Issues 1. Timing Attack on Secret Comparison if token == os.Getenv("API_SECRET") { The == operator on strings is not constant-time. An attacker can measure response timing to...

anthropic/claude-opus-4-8 · 2026-06-11