Datasets:
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 |
End of preview. Expand in Data Studio
Background
This is a Claude-Opus-4.8-xhigh upgrade for angrygiraffe/claude-opus-4.6-4.7-reasoning-8.7k. Generated with Claude API.
How the data is synthesised?
Every example is produced by a two-pass "answer-first, then reason-back" pipeline against the Claude API (claude-opus-4-8), with adaptive thinking on and effort: xhigh for both passes. The reasoning you see in each <think> block is synthetic — a first-person deliberation written to plausibly lead to the answer. It is not the model's real chain-of-thought (Opus 4.8 never exposes raw CoT); this matches the original dataset's design.
Pass 1 — the conversation (answer first, no reasoning)
A single structured-output call generates the whole example: a specific expert/character system persona, and the full set of user↔assistant turns — with polished, senior-practitioner-level answers but no <think> block yet. A JSON-schema constraint guarantees the shape and the exact turn count; user turns are steered to sound like real people (hard rule: ≤20% start with "What"/"How").
Pass 2 — the reasoning (back-filled per turn)
For each assistant turn, a separate call reconstructs a 150–500 word first-person deliberation — parse the ask, choose an approach and weigh alternatives, verify a key step, sanity-check, and plan the presentation — that plausibly precedes that turn's answer. Each reasoning sees only the context available up to its turn (no leakage from later turns) and is not a restatement of the answer as numbered steps. It is prepended as <think>…</think>\n\n{answer}. This is why every assistant turn carries reasoning (100%).
Structural fidelity to the original
Counts are pinned to a deterministic plan matching angrygiraffe/claude-opus-4.6-4.7-reasoning-8.7k exactly: 8,706 examples, the same 28-category distribution, and the same turn-count histogram (1:5252, 2:1491, 3:1858, 4:82, 5:21, 6:2). Output is OpenAI-chat JSONL with fields category / messages / model; each split also ships a *_no_reasoning variant with the <think> blocks stripped.
At a glance
- Generator:
claude-opus-4-8, adaptive thinking,effort: xhigh - ~24M tokens · 8,706 unique system prompts · every assistant turn has a
<think>block - Fully resumable, checkpointed generation
- Downloads last month
- -