Radar

The Pragmatic Engineer on Scion, Anthropic's in-house replacement for git on its monorepo, and Antique, its code review platform. The driver is agent-scale load: merges went from about 2,500 a day in May to over 30,000 a day by September, with about 25 million checkouts a day, mostly from CI, against a 25GB working copy. Server nodes hold the whole repo, changesets live in Spanner and blobs in Cloud Storage, and a team of seven runs it. Also covers the Mononoke attribution dispute and git-compatible alternatives. Read for which bottleneck breaks first when agents multiply merges.

CLI that answers "how does X work" over a codebase instead of grepping for a literal string: walks the filesystem respecting ignore files, uses Vercel's Jev model to judge file and declaration relevance from content previews, and returns matching excerpts with line references. Parses Python and TypeScript/JavaScript declarations natively, falls back elsewhere. Reports matching baseline task success (8/10) on a ten-task SWE-bench comparison at roughly 30% lower coding-agent cost ($5.44 vs $7.62).

Position paper arguing that agent oversight is self-undermining: the cognitive load of monitoring autonomous agents exceeds what interfaces support, extended reliance on agents degrades the critical-thinking skills oversight requires, and approval fatigue pushes reviewers toward superficial rubber-stamping that then gets fed back into training as a weaker judgment signal. Proposes developer-level design affordances (strategic friction, decision design, behavioral monitoring) plus organizational protocols as fixes, treating human cognitive limits as a first-class design constraint rather than an afterthought.

Glossary of agentic-coding terminology (sourced from aihero.dev), grouped into seven areas: core model concepts, session/context management, agent tools and environments, failure modes, multi-session workflows, memory and steering (AGENTS.md, progressive disclosure), and practical work patterns (AFK sessions, human-in-the-loop). Plain-language definitions aimed at developers, not a general AI glossary.

Anthropic's account of speeding up claude.ai web and desktop: deterministic benchmarks (Valgrind instruction counts, React commit tracking, DOM mutation counts) targeting the four user journeys covering 95% of activity, fixes like a static HTML composer mounted during React init, precompiled V8 code caching, and eliminating redundant cache clones and megamorphic lookups. Notable for the process as much as the numbers: Claude ran with standing instructions to find bottlenecks, build benchmarks, and ship PRs autonomously across 150+ concurrent threads, with humans steering ambition and direction. Reports 3.1x average improvement across 13 metrics, including a 19x faster message-send at p75.

A practitioner's guide spanning the full agentic AI stack: transformer architecture, GPU systems, and inference optimization; alignment via RLHF/PPO/DPO; then agentic systems proper (RAG, memory architectures, agent design patterns, inter-agent coordination); closing with dev frameworks, UI design, evaluation, and production deployment. Useful as a single-reference map across the stack rather than for any one novel result.

Introduces HackDetect, a post-hoc audit that flags when a benchmark score comes from an exposure (leaked solutions, evaluation artifacts, generator structure) rather than the intended capability. Auditing 2,385 traces across 15 agent benchmarks finds exposures or reward hacking in 67.0% of Frontier Science traces and 66.7% of AutoLab tasks, with score inflation (the "Mislead gap") from 0.45 to 1.00.

Token-cost profiler for AI agents: ingests OpenTelemetry traces, prices each call against vendored pricing snapshots, and runs eight waste detectors (prompt-caching failures, redundant tool calls, verbosity, model mismatch, and "nonconvergence" loops that thrash without progress) into a 0-100 Token Efficiency grade usable as a CI cost-regression gate. Reports unmeasured values as unknown rather than guessing.

Across nearly 6,000 runs on two office-automation benchmarks and three harness stacks, the best-performing agent skills win mainly by regressing less, not gaining more. Identifies three causes of regression: description osmosis (a skill changes behavior just by being present in context), grounding displacement, and verification displacement, and argues skills should be scored on the gain/regression decomposition rather than aggregate improvement.

Pairs a frozen model with an external memory that distills each episode's outcome verdicts and after-the-fact corrections into retrievable natural-language rules. On the tau-bench banking domain, learning from outcome verdicts alone lifts single-trial success to 1.6x baseline and from corrections to 2.6x, solving 22 of 84 tasks the no-memory baseline never solves; the rule store transfers between Mistral Large and Claude Sonnet 5.

Databricks built roughly 200 tasks from real merged PRs across its multi-language, multi-million-line codebase (sealed git history, neutral problem statements, pass/fail against the original test suite) and found per-token pricing predicts almost nothing about real task cost. Harness choice dominates: one harness sent roughly 3x less context per turn than alternatives for comparable quality, and open models like GLM 5.2 now compete on hard tasks at a fraction of Opus 4.8's per-task cost. Argues for routing by task complexity and measuring cost per verified task instead of $/1M tokens.

Offline behavior-diff CLI for AI agents. Compares traces across model, prompt, or framework changes to surface dropped tool calls, argument drift, output changes, and cost or latency regressions; also supports behavior contracts and CI gates.

Evidence-gated lifecycle control for autonomous coding loops: states such as tested, done, and ready-to-merge require fresh, mechanically verifiable evidence bound to the current source state. The evaluation emphasizes preventing false-DONE outcomes and rejecting tampered evidence bundles.

Empirical study of 31,073 CodeRabbit reviews and developer responses. Only 36.4% of suggestions were accepted, while 56.3% were rejected, commonly for false positives, redundancy, scope errors, or misalignment with developer intent.

Open, multi-domain coding-agent benchmark spanning code, web, office, and security work. Tasks are reverse-engineered from real commits and business scenarios, then rewritten to resist prompt recovery and contamination while retaining reproducible environments, tests, and reference solutions.

Decomposes reliability gains in a production enterprise agent across verification loops, specialist models, routing, and scaffolding. Most uplift came from scaffolding and specialists; the verification step added less overall but rescued difficult failures near the top of the score range.

Cate maps native hooks from Claude Code, Codex, Cursor, Grok, OpenCode, and Pi into one lifecycle event stream for working, awaiting input or permission, and finished states. The adapters deliberately avoid inferring state when a CLI's signals are ambiguous.

Local-first memory layer that captures the reasoning, alternatives, linked files, and agent context behind each commit, then rolls it up by branch for later recall through MCP. Designed to keep context portable across coding agents, with optional cloud sync and workflows for living specs, reports, and documentation.

Opinionated, semi-deterministic codegen: one declarative ProblemSpec in, a buildable Clean-Architecture app out. Uses small, pattern-specialized agents (a 34-pattern library) instead of one big-context model, and runs in reverse to refactor brownfield code onto the dependency rule. Interesting for the small-model, architecture-first bet.

Anthropic Frontier Red Team with Theorem (2026-10-22). Claude turned OSS-Fuzz entry points into specifications and wrote Rocq proofs that 239 entry points across 123 open-source libraries never crash from memory-safety errors or failed assertions on inputs up to 64 MB, about 180 million lines of proof checked at the RISC-V assembly level, finding hundreds of bugs on the way. The proofs assume single-threaded static musl binaries, a Linux model and the trusted semantics, so they are bounded claims, not "bug-free". Worth reading for the fuzz-test to specification move and the cost: proofs can take hundreds of millions of tokens.

Semgrep's IDOR benchmark finds Kimi K3 competitive on aggregate F1 but substantially weaker on precision and on the largest enterprise-style repository. A useful case for evaluating false-positive triage cost and representative repository scale, not headline scores alone.

Explains Hegel's property-based testing architecture: a Rust core (libhegel) handles generation, shrinking failing cases to a minimal reproducer, and an example database, while thin per-language bindings (Rust, Go, C++, TypeScript, Java, OCaml) request typed generated values from it during test runs. Now the house rule's designated property-testing tool for parsers, codecs, round-trips, and other pure-logic invariants outside Python (which stays on Hypothesis).

Agent skill (SKILL.md) for gating and auditing test value, not just coverage. An authoring gate requires four answers before a new test lands (behavior protected, credible regression, why existing coverage misses it, whether it forces a test-only production seam), plus a catalogued "junk pattern" list (assertion-free probes, source greps, mocks that implement the behavior they assert, self-fulfilling fixtures) shared by both new-test review and sweep-style audits of low-value or implementation-coupled tests. Complements crap4java and supercov's coverage-quantity lens with a test-quality-per-test lens.

MIT-licensed CLI (npx supercov) that gives a coding agent targets: it scores per-file code quality via TypeSafe AI's Jev model (yes/no questions per file, arithmetic done locally, about a cent per MB of source), runs your existing test command, and turns uncovered paths into small queries the agent can write tests or refactors against. Covers JS/TS, Rust, Python, Ruby, Go, Java, Kotlin. Compare with crap4java's complexity-times-coverage approach.

Uncle Bob's Quil-based live UML class-diagram viewer, driven by an EDN topology + policy file. Overlays cyclomatic complexity, coverage, and mutation-testing metrics, enforces Clean Architecture dependency direction, and lets you preview alternative component groupings without touching source. Worth a look alongside the LikeC4 orient export.

Uncle Bob's CRAP metric (Change Risk Anti-Patterns) for Java, complexity weighted by test coverage.

Obsidian vault scaffold run by a Claude Code agent as a self-maintaining personal knowledge base: an ingestion pipeline turns saved articles, PDFs, and transcripts into linked wiki pages, split into a knowledge layer (what you know) and a projects layer (what you're doing), retrieved via structured wikilinks rather than vector similarity. Ships as 72 slash commands and 18 agent skills over MCP, plus Python tooling for link checking, stats, and graph export. Relevant to compare against the Obsidian vault setup and this site's own knowledge hub / graph pipeline.

Prose linter for AI writing tells in Markdown and plain text. Countable rules (long dashes, banned words, uniform sentence length) run locally as regexes; judgment rules (restating closers, stacked hedges) send one paragraph at a time to a small hosted Jev model after an explicit yes. Flags only, never rewrites; ships as CLI, GitHub Action, pre-commit hook and Claude Code plugin. Candidate check for the no-ai-slop pass.

Peter Yang's collected patterns for keeping AI writing from reading like AI. Mine against for my own rules.

TypeSafe AI's pitch for a non-chat model class built for automation: Jev outputs type-safe structured values instead of text, claims 40x-200x lower latency than frontier LLMs (70-500ms), free output tokens, and calibrated confidence scores via a "Reinforcement Learning for Calibrated Decisions" training method. Early access; worth watching as a structured- decision alternative to LLM-in-the-loop automation.

Free hands-on book (v0.3, "GenAI edition") pairing theory with runnable Colab notebooks: neural surrogates/operators, physics-informed losses, differentiable physics solvers, diffusion/flow-matching for uncertainty quantification, RL control of physical systems. A solid reference map across the field rather than a single result.

General Physics Transformer (GPhyT), trained on 1.8TB of simulation data across fluid-solid interaction, shock waves, thermal convection, and multi-phase dynamics. Claims 7x over specialized architectures and in-context generalization to unseen systems without being told the governing equations — a physics analog to the LLM foundation-model bet.

Survey of foundation models applied to Earth science, tracking the progression from image-recognition-level perception to scientific reasoning and autonomous workflows. Catalogs 200+ datasets/benchmarks across weather, water, geology, ecosystems, and ice, and names the open challenges (multimodal data, scientific accuracy, infra scaling).

Survey of two complementary strategies for injecting physics into ML forecasting of PDE-governed systems: embedding physics into loss functions/architectures/synthetic data, versus treating data itself as encoded physics via multi-task/meta/contextual learning. Includes an industrial-applications angle and a map of open-source PIML tooling.

Separates retrieval keys from generation evidence instead of using the same chunks for both. Semantic key-value records and provenance pointers improve coverage, context assembly, and retrieval latency, especially under tight token budgets.

Tufte / Visual Display of Quantitative Information principles as a plugin. Check for the dataviz skill.