Claude Opus 5 vs GPT-5.6 for Coding: SWE-bench, Terminal-Bench & Real Dev Workflows

Scenario A: Refactoring a Messy React Component

Illustrative code — the kind of extraction being asked for:

// Extracted hook — data fetching pulled out of the component,
// with a cancellation guard so a fast userId change can't let a
// stale response overwrite newer state.
function useUserDashboard(userId: string) {
  const [user, setUser] = useState<User | null>(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState<Error | null>(null);

  useEffect(() => {
    let cancelled = false;
    setLoading(true);

    fetchUser(userId)
      .then((u) => { if (!cancelled) setUser(u); })
      .catch((e) => { if (!cancelled) setError(e); })
      .finally(() => { if (!cancelled) setLoading(false); });

    return () => { cancelled = true; };
  }, [userId]);

  return { user, loading, error };
}

This is genuine example code illustrating the refactor pattern — not a captured model transcript.

Scenario B: Debugging a Race Condition in Async Code

Illustrative code — a real cache-stampede race and a common fix:

// Buggy: two concurrent calls can both miss the cache and both
// pay for a slow fetch, racing to write the result.
const cache = new Map<string, User>();

async function getUser(id: string): Promise<User> {
  if (cache.has(id)) return cache.get(id)!;
  const user = await fetchUserFromApi(id); // 300-800ms
  cache.set(id, user);
  return user;
}

// Fixed: dedupe concurrent lookups for the same id via an
// in-flight promise map, so only one fetch ever runs per id.
const cache = new Map<string, User>();
const inFlight = new Map<string, Promise<User>>();

async function getUser(id: string): Promise<User> {
  if (cache.has(id)) return cache.get(id)!;
  if (inFlight.has(id)) return inFlight.get(id)!;

  const promise = fetchUserFromApi(id)
    .then((user) => {
      cache.set(id, user);
      inFlight.delete(id);
      return user;
    })
    .catch((err) => {
      inFlight.delete(id);
      throw err;
    });

  inFlight.set(id, promise);
  return promise;
}

Real, runnable example illustrating the bug class — not a captured model output.

Scenario C: Understanding & Documenting an Unfamiliar Codebase

Illustrative code — before and after documentation:

/**
 * Buckets raw event timestamps into fixed-size windows and returns
 * a running count per window. Used by the dashboard's activity
 * heatmap and by the retention-cohort report (see cohorts.ts).
 *
 * Edge case: events must be pre-sorted ascending — the function
 * does not sort them, so unsorted input silently produces wrong
 * bucket boundaries rather than throwing.
 *
 * @param events - Unix ms timestamps, sorted ascending
 * @param windowMs - Bucket width in ms (e.g. 3_600_000 for hourly)
 * @returns Map of window start (ms) -> event count in that window
 */
function bucketEvents(events: number[], windowMs: number): Map<number, number> {
  const buckets = new Map<number, number>();
  for (const ts of events) {
    const windowStart = Math.floor(ts / windowMs) * windowMs;
    buckets.set(windowStart, (buckets.get(windowStart) ?? 0) + 1);
  }
  return buckets;
}

Genuine example code with the kind of doc comment this task asks for — not a model transcript.