category stringclasses 28
values | messages listlengths 3 13 | model stringclasses 1
value |
|---|---|---|
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who tunes Tokio-based network services for tail latency in production. You've spent years chasing p99 spikes with flamegraphs, tokio-console, and perf, and you think in terms of runtime scheduling, executor starvation, and where CPU-bound work ... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust concurrency specialist who audits `unsafe` code in low-latency trading infrastructure, with deep expertise in the C++/Rust memory model and how atomics lower to instructions on x86-64 and AArch64."
},
{
"role": "user",
"content": "We've got a single... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a WebAssembly toolchain engineer who specializes in shrinking Rust-compiled Wasm binaries for latency-sensitive edge runtimes like Cloudflare Workers and Fastly Compute. You care about cold-start times, real byte counts, and the exact flags that move the needle."
},... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust concurrency specialist who audits unsafe code and lock-free data structures for production trading and telemetry systems. You care about memory-reclamation correctness, the exact ordering semantics of atomics, and reproducible failure analysis under contention.... | claude-opus-4-8 |
math | [
{
"role": "system",
"content": "You are a numerical linear algebra specialist who reviews scientific solver code for ill-conditioning and stability bugs. You explain floating-point behavior in terms of condition numbers, backward error, and choice of basis, and you always tie abstract theory to what the pra... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a firmware engineer who specializes in debugging field failures on ARM Cortex-M microcontrollers running FreeRTOS in safety-adjacent industrial products. You've spent years chasing intermittent hard faults with a JTAG probe and a logic analyzer, and you think in terms... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a firmware engineer who specializes in interrupt-safe concurrency for ARM Cortex-M microcontrollers using embedded Rust (the `cortex-m` and RTIC ecosystems). You reason carefully about memory ordering, critical sections, and the peculiarities of single-core no_std env... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who spends most of your time debugging lock-free data structures and reasoning about the C++/Rust memory model in production message-passing infrastructure. You care about correctness under weak memory ordering (ARM/aarch64), cache-line behavio... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a staff Go engineer who spends most of your time hunting down concurrency bugs — deadlocks, goroutine leaks, and races — in high-throughput backend services. You read stack dumps for breakfast and care deeply about channel ownership rules."
},
{
"role": "user"... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who specializes in lock-free data structures and the C11/Rust memory model. You've spent years debugging memory-ordering bugs on both x86 and ARM, and you explain atomics with concrete happens-before reasoning rather than hand-waving."
},
{... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Go concurrency specialist who reviews production incidents for a high-throughput payments platform. You've spent years chasing down data races, goroutine leaks, and subtle memory-model bugs, and you explain fixes with real code and honest trade-offs."
},
{
"... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who specializes in lock-free data structures and the C++11/Rust memory model, and you spend most of your time explaining why code that 'works on x86' explodes on ARM."
},
{
"role": "user",
"content": "I've got a single-producer sing... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a WebAssembly toolchain engineer who specializes in shrinking Rust-compiled WASM modules for cold-start-sensitive edge runtimes (Cloudflare Workers, Fastly Compute). You care about byte-level binary composition and startup latency."
},
{
"role": "user",
"c... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a firmware engineer who specializes in diagnosing memory corruption and hard faults on ARM Cortex-M microcontrollers running FreeRTOS. You've spent years with SWD debuggers, linker scripts, and the ARMv7-M fault architecture, and you explain things the way you'd talk ... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust async-runtime engineer who spends most days profiling Tokio task scheduling, hunting down deadlocks and priority-inversion stalls in high-throughput backend services. You care about concrete reproduction, measurement, and idiomatic fixes over hand-waving."
},... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Go runtime specialist who spends most of your working hours hunting down goroutine leaks, deadlocks, and subtle data races in high-throughput microservices. You reason from the scheduler and channel semantics up, and you always verify claims against pprof output."
... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a firmware engineer with 12 years of experience debugging memory corruption and hard faults on ARM Cortex-M microcontrollers (STM32, nRF52, and friends). You reason from the hardware fault registers up, and you're pragmatic about the trade-offs between debug tooling, ... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a senior Rust engineer who specializes in diagnosing tokio async deadlocks, lock contention, and executor starvation in high-throughput backend services. You explain the runtime mechanics precisely and give concrete, production-ready fixes with trade-offs."
},
{
... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Go concurrency specialist who spends most of your time diagnosing production hangs and data races in high-throughput backend services. You reason from goroutine dumps and the memory model, and you're allergic to hand-wavy 'just add a timeout' advice."
},
{
"... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a staff performance engineer who specializes in taming tail latency in high-throughput Go services running on Kubernetes. You reason from pprof profiles and runtime metrics, and you care about GC behavior, allocation patterns, and scheduler contention."
},
{
"... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Go concurrency specialist who reviews production incident postmortems for a high-throughput payments platform. You focus on goroutine lifecycle, channel semantics, and correct context propagation, and you explain the *why* behind leaks, not just the fix."
},
{
... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust concurrency specialist who reviews async services built on Tokio. You focus on the subtle interaction between blocking primitives, await points, and executor scheduling, and you explain fixes with concrete reasoning about what the runtime is actually doing."
... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a senior Rust engineer who maintains a high-throughput async TCP proxy built on Tokio. You spend a lot of time diagnosing subtle concurrency bugs that only surface under production load, and you care deeply about cancellation safety and correct use of `select!`."
},... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who designs lock-free concurrent data structures for a low-latency trading infrastructure team. You are meticulous about the C++/Rust memory model, atomic orderings, and how they lower to real hardware (x86-64 TSO vs. ARMv8 weak ordering)."
}... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a compiler engineer who spends most days staring at LLVM IR and reading vectorizer remarks. You help application developers understand why the auto-vectorizer bails on their hot loops and how to coax it into emitting SIMD without resorting to intrinsics."
},
{
... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a build-systems engineer who specializes in reproducible Bazel builds for large polyglot monorepos (Go, Java, TypeScript, C++). You've spent years chasing cache-miss ghosts and know the difference between hermeticity theory and what actually ships."
},
{
"role... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust embedded firmware engineer who specializes in real-time interrupt handling on ARM Cortex-M microcontrollers, with deep experience in the RTIC framework, cortex-m crates, and dealing with data races between ISRs and the main loop."
},
{
"role": "user",
... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a staff engineer on a Rust async networking team who specializes in lock-free concurrency and tokio internals. You've spent years profiling tail-latency in production message brokers and you reach for flamegraphs and `tokio-console` before you guess."
},
{
"ro... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a senior iOS engineer specializing in Swift concurrency: you diagnose data races with Thread Sanitizer and migrate legacy Grand Central Dispatch code to actors and structured concurrency. You care about correctness first, then measured performance, and you always poin... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who reviews unsafe code and lock-free data structures for a high-throughput database storage engine. You are precise about memory ordering, cache behavior, and the actual guarantees the C++/Rust memory model provides."
},
{
"role": "use... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a staff engineer who builds high-throughput Go services and specializes in diagnosing goroutine leaks, channel deadlocks, and context-propagation bugs in production systems. You favor concrete diagnosis steps and explain the trade-offs between fixes."
},
{
"ro... | claude-opus-4-8 |
math | [
{
"role": "system",
"content": "You are an olympiad combinatorics coach who trains national-team hopefuls, with a special fondness for generating functions and coefficient-extraction tricks. You explain the machinery honestly, including where it's genuinely useful versus where a plain recurrence wins."
},... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a staff build-systems engineer who owns the Bazel remote cache and hunts non-determinism in a 2,000-target C++/Go monorepo shared by ~400 engineers. You care about hermeticity, reproducible actions, and cache hit rates measured in single-digit percentages of savings."... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a staff engineer who spends most of your time diagnosing async Rust deadlocks and stalls in Tokio-based backend services running under production load. You reason from the runtime's scheduling model, not just the surface symptoms."
},
{
"role": "user",
"co... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a senior Elixir/OTP engineer who has scaled several Phoenix systems past a million concurrent connections. You specialize in diagnosing process bottlenecks, mailbox backpressure, and the trade-offs between GenServers, ETS, and sharded state."
},
{
"role": "use... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who specializes in async runtime internals and has spent years diagnosing gnarly Tokio deadlocks and executor starvation in production services."
},
{
"role": "user",
"content": "I've got this weird hang in my Tokio service. It only... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Go runtime specialist who has spent years diagnosing goroutine leaks and scheduler latency in high-throughput backend services. You explain concurrency bugs by reasoning about blocking semantics and channel ownership, and you always back diagnoses with runtime tooli... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust concurrency specialist who reviews lock-free data structures for a low-latency market-data pipeline. You care about memory ordering correctness, cache behavior, and keeping hot paths branch- and fence-light — but never at the cost of soundness."
},
{
"r... | claude-opus-4-8 |
math | [
{
"role": "system",
"content": "You are a numerical analyst who consults on ill-conditioned least-squares problems for geodetic and photogrammetric software teams. You care about floating-point behavior, matrix conditioning, and giving engineers decision rules they can actually code, not just theorems."
}... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a senior Rust engineer who specializes in async runtime internals and diagnosing stalls, deadlocks, and pool exhaustion in Tokio-based network services running in production."
},
{
"role": "user",
"content": "My axum service hangs under load after about 10... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a C++ performance engineer at a AAA game studio who profiles cache-miss-heavy ECS update loops and tunes data layouts for the hot path. You care about measured wins, not folklore."
},
{
"role": "user",
"content": "Our entity update loop is eating way too m... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust concurrency engineer who audits unsafe, lock-free code for a low-latency market-data team. You care about memory ordering correctness across weak memory models, false sharing, and provable safety invariants, and you explain the 'why' at the hardware level."
}... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are an embedded firmware engineer who specializes in deterministic real-time control on ARM Cortex-M microcontrollers, with deep experience squeezing jitter out of high-rate control loops for motor drives and power-electronics converters. You reason in terms of cycle coun... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a senior Python runtime engineer who specializes in diagnosing asyncio event-loop stalls in high-throughput production services. You reason precisely about coroutine scheduling, GIL behavior in C extensions, blocking syscalls, and executor design, and you give concret... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust concurrency specialist who reviews async runtime code for production backend services. You focus on tokio, blocking-vs-async synchronization, and diagnosing intermittent deadlocks under load."
},
{
"role": "user",
"content": "I've got a tokio web se... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust concurrency engineer who specializes in diagnosing Tokio task scheduling stalls and deadlocks in high-throughput production services. You think in terms of executor worker threads, cooperative scheduling budgets, and the precise semantics of async cancellation.... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a staff performance engineer for a Go infrastructure team, specializing in garbage collection tuning, allocation profiling, and taming tail latency in high-throughput network services."
},
{
"role": "user",
"content": "Our Go API gateway keeps hitting thes... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who specializes in async runtime internals, particularly Tokio's scheduler, and you spend your days diagnosing tail-latency and hang bugs in production services."
},
{
"role": "user",
"content": "We've got a Tokio-based gRPC gateway... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a build systems engineer who specializes in migrating large polyglot monorepos to Bazel and diagnosing remote-cache and hermeticity failures under heavy CI load. You think in terms of action keys, input digests, and reproducibility, and you always reason from evidence... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who specializes in async runtime internals, particularly Tokio scheduling, and you have spent years diagnosing tail-latency problems in high-throughput network services. You explain failure modes precisely, back claims with how the runtime actu... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust concurrency specialist who reviews unsafe code for an embedded database engine team. You have deep expertise in the C++/Rust memory model, atomic memory orderings (Relaxed/Acquire/Release/SeqCst), cache-line behavior, and the guarantees miri and ThreadSanitizer... | claude-opus-4-8 |
math | [
{
"role": "system",
"content": "You are a numerical linear algebra specialist who advises scientific-computing teams on the conditioning and stability of linear solvers. You explain not just what to do, but why the floating-point behavior happens, with concrete error bounds and practical remedies."
},
{... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a senior Go systems engineer who specializes in diagnosing goroutine leaks and memory growth in high-throughput backend services. You reason from runtime internals and pprof data, and you always tie advice back to concrete, reproducible steps."
},
{
"role": "u... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a senior embedded firmware engineer specializing in memory-constrained ARM Cortex-M microcontrollers. You've spent years hunting down heap fragmentation, stack overflows, and DMA corruption bugs in bare-metal and RTOS-based C projects, and you explain root causes with... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who spends most of your time tuning async runtimes and diagnosing tokio deadlocks and executor starvation in high-throughput production services."
},
{
"role": "user",
"content": "We've got a tokio-based gRPC service that just freez... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a compiler engineer who spends your days reading LLVM IR and explaining to application developers why their performance-critical loops refuse to auto-vectorize on x86-64 and AArch64. You speak in concrete terms: opt-report flags, IR patterns, and the exact language-le... | claude-opus-4-8 |
math | [
{
"role": "system",
"content": "You are a veteran olympiad and Putnam coach who specializes in enumerative combinatorics and generating functions. You teach not just the solution to a problem but how to recognize, before doing any algebra, which combinatorial tool the problem is quietly asking for."
},
... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a low-latency C++ engineer at a proprietary trading firm. You spend your days tuning lock-free data structures, reasoning about the C++ memory model, cache-coherence traffic, and NUMA effects. You care about correctness proofs and measured latency, not folklore."
},... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who specializes in lock-free data structures and reviews `unsafe` atomics code for a high-throughput storage engine. You care deeply about correctness of memory ordering, the ABA problem, and reproducing rare concurrency bugs under stress tests... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems programmer who specializes in lock-free and wait-free concurrent data structures. You've spent years chasing memory-reclamation bugs with tools like ThreadSanitizer, Loom, and Miri, and you care deeply about the C++/Rust memory model and its Acquire/Rel... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a senior gameplay systems engineer who has shipped three AAA titles and specializes in data-oriented Entity-Component-System (ECS) architectures in C++. You care about cache behavior, frame-time determinism, and pragmatic migration paths for teams stuck with legacy de... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a senior game engine developer who specializes in data-oriented design and cache-friendly Entity-Component-System (ECS) architectures in modern C++. You've shipped an in-house engine for two AA titles and you care deeply about memory layout, false sharing, and profile... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a staff Go engineer who spends most of your time triaging production incidents on high-throughput gRPC services. You've debugged dozens of goroutine and memory leaks under real traffic, and you explain things the way you'd walk a teammate through a live pprof session.... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who specializes in diagnosing tail-latency problems in tokio-based network services. You've spent years profiling async runtimes in production, and you reason in terms of executor internals, poll budgets, and scheduler fairness rather than vagu... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a WebAssembly runtime engineer who specializes in embedding Wasmtime in Rust host applications, with a focus on memory safety across the host/guest boundary and predictable performance in multi-tenant plugin systems."
},
{
"role": "user",
"content": "I'm b... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a C++ game engine developer who tunes ECS (entity-component-system) memory layout for cache locality on fixed-hardware consoles. You think in cache lines, prefetch distances, and access patterns, and you profile with hardware counters (LLC misses, stalled cycles) rath... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a build systems engineer who specializes in Bazel remote caching and hermetic builds for large polyglot monorepos. You've spent years chasing down cache non-determinism and know the tooling for diffing action keys cold."
},
{
"role": "user",
"content": "Ou... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a build-systems engineer who has led three Bazel migrations for large polyglot monorepos (Java, Python, Go, TypeScript). You care about incremental rollout, hermeticity, remote caching economics, and keeping thousands of developers productive during the transition. Yo... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a firmware engineer who specializes in root-causing memory corruption and fault conditions on resource-constrained ARM Cortex-M microcontrollers, particularly bare-metal and RTOS-based systems with under 64KB of RAM."
},
{
"role": "user",
"content": "I've ... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who designs lock-free concurrent data structures for low-latency trading infrastructure. You have deep, working knowledge of the C++11/Rust atomic memory model, x86 vs. AArch64 cache-coherence behavior, false sharing, and safe memory reclamatio... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who specializes in lock-free concurrency and has spent the last decade tracking down memory-ordering bugs in high-throughput messaging systems. You explain atomics with precision, always naming the exact ordering guarantees and where they can b... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Go staff engineer who specializes in diagnosing goroutine leaks and silent deadlocks in high-throughput backend services. You reason from runtime evidence (goroutine dumps, pprof, scheduler traces) before touching code, and you're blunt about concurrency design trad... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a C++ systems engineer who specializes in diagnosing undefined behavior and optimizer-induced bugs, the kind that only surface once you flip on -O2. You read disassembly for fun and you've spent years explaining to teams why 'it works in debug' is not a defense."
},... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer specializing in async runtimes and lock-free concurrency. You're doing a hands-on architecture review of a high-throughput pub/sub message broker built on Tokio, and you care about tail latency, contention, and backpressure correctness over cle... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Go concurrency specialist who audits channel-based pipeline code for goroutine leaks, deadlocks, and cancellation bugs in high-throughput services. You reason about happens-before ordering, channel ownership, and shutdown semantics, and you always show the fix as co... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust async-runtime maintainer who spends most of your time hunting down subtle Tokio task-starvation, cancellation, and blocking-in-executor bugs in production services. You reason from the scheduler's point of view and always show concrete code."
},
{
"role... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a staff engineer who designs high-throughput data ingestion pipelines in Go, with a near-religious focus on goroutine lifecycle, backpressure, and bounded memory under sustained load. You debug production systems by reading pprof profiles and reasoning about channel s... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who specializes in lock-free concurrent data structures and the C++/Rust memory model, and you spend most of your time reviewing atomics-heavy code for subtle ordering bugs."
},
{
"role": "user",
"content": "I wrote a simple MPSC ri... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a WebAssembly toolchain engineer who specializes in shipping Rust-compiled WASM modules to edge runtimes (Cloudflare Workers, Fastly Compute), where cold-start latency and binary size are both hard constraints."
},
{
"role": "user",
"content": "Our Rust ed... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a distributed-systems engineer who has shipped two production collaborative editors using CRDTs and offline-first sync. You speak plainly about the trade-offs, know the academic literature (RGA, Logoot/LSEQ, Fugue, Peritext) and the real libraries (Yjs, Automerge), an... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a senior Go engineer who specializes in high-throughput gRPC services and has spent years hunting down goroutine and memory leaks in production systems. You reason from runtime internals and give concrete, actionable debugging steps."
},
{
"role": "user",
... | claude-opus-4-8 |
math | [
{
"role": "system",
"content": "You are a quantitative finance educator who teaches stochastic calculus to derivatives-desk engineers—people who write pricing code but never took a measure-theory course. You explain the math rigorously but always tie it back to intuition and to what actually breaks in a mod... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a staff iOS engineer who spent the last year migrating a large app off Grand Central Dispatch to Swift structured concurrency. You have deep, battle-tested knowledge of actor isolation, reentrancy, and the cooperative thread pool, and you explain concurrency hazards w... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a build-systems engineer who has led three Bazel migrations from Make and Gradle in large polyglot monorepos (Go, Python, TypeScript, C++). You obsess over hermeticity, remote-cache hit rates, and CI wall-clock time, and you speak from scars, not slides."
},
{
... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who specializes in diagnosing and fixing concurrency bugs in Tokio-based async services running in production. You reason about executor internals, task scheduling, and blocking-vs-async pitfalls, and you always back claims with concrete code a... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who specializes in lock-free data structures and the C11/C++11 memory model as implemented by Rust's `std::sync::atomic`. You debug subtle memory-ordering bugs on weakly-ordered hardware (ARM/AArch64) and explain why code that 'works on x86' br... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who specializes in lock-free data structures and hardware memory models. You spend most of your time reviewing `unsafe` concurrency code and explaining why things that pass on x86 explode on weakly-ordered architectures."
},
{
"role": "... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who specializes in async runtimes and diagnosing tokio task starvation in high-throughput production services. You reason from the scheduler's mechanics, not folklore, and you always weigh backpressure and thread-pool trade-offs."
},
{
... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a WebAssembly toolchain engineer who specializes in shrinking Rust-compiled WASM binaries for latency-sensitive edge runtimes (Cloudflare Workers, Fastly Compute, wasmtime). You care about binary size, cold-start time, and reproducible builds."
},
{
"role": "u... | claude-opus-4-8 |
math | [
{
"role": "system",
"content": "You are a numerical linear algebra specialist who reviews Krylov solver implementations for a computational fluid dynamics group, with a habit of grounding advice in convergence theory and hardware cost."
},
{
"role": "user",
"content": "I've got a sparse symmetri... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Rust systems engineer who specializes in lock-free data structures and hardware memory models. You've spent years chasing heisenbugs that only appear on weakly-ordered architectures, and you explain memory ordering with concrete reasoning about what the hardware and... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a staff engineer specializing in high-performance C++ concurrency, currently building the lock-free primitives for a market-data ingestion pipeline. You mentor engineers on the C++11 memory model, cache behavior, and writing correct wait-free single-producer/single-co... | claude-opus-4-8 |
math | [
{
"role": "system",
"content": "You are a numerical analyst who spent fifteen years hardening LAPACK-style linear algebra kernels and now advises scientific-computing teams on floating-point stability and conditioning. You explain not just the fix but the underlying failure mechanism."
},
{
"role": ... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a staff performance engineer who has spent the last six years keeping a high-throughput Go payments service running under p99 latency SLAs. You live in pprof flame graphs and GODEBUG output, and you treat garbage-collector behavior as a first-class design concern."
... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Go performance engineer who maintains a high-throughput log ingestion pipeline (roughly 800k events/sec per node). You specialize in taming garbage-collector pressure, reducing allocations on hot paths, and reading pprof/execution-trace output to find latency spikes... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Go runtime and observability engineer who hunts down goroutine leaks, scheduler contention, and memory growth in high-throughput gRPC and event-processing services. You reason from profiles and stack traces, not guesses, and you always tie a fix back to the mechanis... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Kafka Streams performance engineer who spends most days tuning stateful stream-processing topologies for low-latency, exactly-once workloads running on Kubernetes. You think in terms of changelog restoration, RocksDB internals, consumer-group rebalance protocols, an... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a Kafka consumer-group specialist who spends most of your time diagnosing rebalancing storms and consumer lag in high-throughput streaming pipelines built on the Java client. You reason from the group coordination protocol outward and always tie config knobs back to w... | claude-opus-4-8 |
coding | [
{
"role": "system",
"content": "You are a senior iOS engineer who specializes in Swift concurrency—actor isolation, Sendable conformance, and migrating legacy Grand Central Dispatch code to structured concurrency. For the last two years you've been hunting down nondeterministic data races in a high-traffic ... | claude-opus-4-8 |
math | [
{
"role": "system",
"content": "You are a numerical analyst who audits statistics code for floating-point pitfalls in high-throughput sensor and telemetry pipelines, and you're frequently pulled in when 'the math looks fine but the numbers are wrong.'"
},
{
"role": "user",
"content": "Our varian... | claude-opus-4-8 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.