THE COLLECTION

Library

Everything you’ve found. Nothing you need to save twice.

19 articles
Browse at your own pace.

Post 50: Good Research Takes are Not Sufficient for Good Strategic Takes — Neel Nanda

The author argues that being good at AI research is only weak evidence of being good at strategic thinking about AGI. Research offers clear feedback; strategy does not, so researchers can hold bad strategic views and never correct them. He lists skills good strategic takes need and asks readers to check what evidence supports a person's strategic claims.

Post 51: Socratic Persuasion: Giving Opinionated Yet Truth-Seeking Advice — Neel Nanda

The author recommends giving advice by breaking your argument into key steps and asking the other person questions about each step. If you get an unexpected answer, you likely missed context, so you can pivot early. The method requires real humility and willingness to change your mind, and costs more time and effort than direct advice.

How the Claude Code team does code review

This article describes the code review process of the Anthropic team behind Claude Code. Agents write most of the code, so machines do most of the reading and humans approve by risk tier. The tradeoff is less human review time, but mistakes still pass, so the team needs rollback, telemetry, and clear ownership.

How to keep enjoying programming in a world of LLMs

A Haskell developer, worried about LLM-driven burnout and skill atrophy, argues against full vibe coding: you should keep writing code yourself while delegating planning, research, review cycles, and low-risk cleanup to agents. The tradeoff is accepting modest productivity gains (roughly 2x by his estimate) instead of boasting numbers, in exchange for retaining enjoyment, codebase ownership, accountability, and independence from token limits and frontier-model vendors.

When AI writes almost all code, what happens to software engineering?

Arguing that late-2025 model releases (Opus 4.5, GPT-5.2, Gemini 3) made AI-generated code good enough to supplant hand-coding, the author blends anecdotes from prominent engineers with predictions about the profession. Specialized coding skills and hand-writing code lose value, while testing, architecture, product thinking, and verification become the engineer's core role. Tradeoffs include faster shipping at the cost of quality and accountability, though the piece rests on anecdotes and largely assumes its central claim holds.

OpenCode Reloaded

This article explains how OpenCode 2 achieves instant hot reloading of plugins, config, and MCP servers. Mutating shared state from multiple plugins causes order-dependent bugs, so plugins instead register transformation functions that OpenCode replays in order from an empty state on every rebuild. The tradeoff is that plugins give up direct, arbitrary mutation in exchange for deterministic, coordinated reloading.

Your Agent Aced the Task. Will It Do It Again?

The article argues that average benchmark accuracy hides agent unreliability: a ReAct agent on GPT-4.1 scored 77.4% Mean@5 on AppWorld but only 53.0% Pass^5 (succeeding on every run). Their Consistency Analyzer resamples decision points from a single recorded trajectory to find flip-prone steps, and the resulting injected guidelines halved the gap (24.4pp to 12.0pp) without costing average accuracy. Tradeoffs: diagnosis needs one extra LLM call per decision step, and consistency is orthogonal to capability, so a bigger model won't fix it.

Marketing ops as code: Automating events from planning to follow-up on GitHub

A GitHub marketing lead automated event operations end-to-end by treating each event as a GitHub Issue: issue forms capture inputs, labels act as triggers, GitHub Actions stage the event, and Copilot 'skills' (Markdown runbooks) handle planning and post-event follow-up. She argues the pattern applies to any repetitive work touching tools with an API or CLI, weighing it against packaged marketing-automation platforms: regional variation favors custom pipelines with PR-based change management, though a silent cron failure shows monitoring is still required.

Building Agents that Don't Break Themselves

The article argues that an AI agent's long-lived process (its 'home') and the sandbox where it executes model-generated commands should be separate environments. It presents two Fly.io case studies: SpriteDoc uses a throwaway sandbox per session with per-command credential injection, while Hermes Agent keeps a persistent per-task sandbox. Tradeoffs include lifecycle choice, idle cost (sandboxes go cold), and replacing approval prompts with sandbox isolation plus cheap checkpoint/restore rollback.

My agent.md to improve LLM-assisted code quality

The author recounts moving from unusable LLM code in 2025 to productive agentic coding in 2026, then shares the agent.md file they built to encode recurring code-review corrections as prompt rules: concise comments, no magic numbers, early returns, private-by-default visibility, layered architecture, commit conventions, and test-first bug fixes. It reduces repetition and frees review time for architecture, but is no magic bullet — hallucination and verification remain, and 'context dilution' degrades adherence, mitigated by short sessions and reloading agent.md.

I don't like passkeys

The article argues passkeys are technically strong—phishing-proof and breach-resistant—making them well-suited to enterprises, but a poor fit for individuals whose bigger risks are lockout, account bans, and device loss. It details pain points: hardware keys can't be backed up and have per-key credential limits, platform-synced passkeys tie you to Apple/Google accounts, export/interoperability is immature, and cross-device login is clunky. It recommends passwords in a third-party manager plus a separate TOTP app, except for habitual password reusers.

Laya — 33ms Multilingual System 1 Decision Engine

The author introduces Laya, an open-source family of bidirectional encoder models that answer typed questions (choice, ordinal score, boolean) with calibrated probabilities in roughly 33 ms, arguing generative LLMs are overkill for high-volume triage and routing. Self-reported benchmarks claim speed, calibration, and cost advantages over the proprietary Jev API. Acknowledged tradeoffs: choice questions degrade beyond ~20 options, base checkpoints are near-random zero-shot and require fine-tuning, and temperature calibration is needed.

Improving infrastructure efficiency for growing demand in the age of AI

Dropbox argues that as AI-driven demand grows, getting more from existing infrastructure matters as much as building new data centers. The post describes a system-level approach spanning power management (Deep Sleep), workload rebalancing, higher storage density via SMR drives, and failure-rate-driven hardware lifecycle decisions, reporting watts per petabyte improved over 50% since 2020. Tradeoffs include density versus power/cooling needs, energy savings versus latency, and longer hardware life versus reliability risk.

How we used DSPy to turn AI evaluations into better responses in Dash chat

Dropbox built trajectory-based LLM-as-judge evaluations for its Dash chat agent, then used DSPy's GEPA and MIPROv2 optimizers in two stages: calibrating judges against a small human-labeled set, then optimizing the agent's system prompt via offline replay of historical chats. Reported gains include 26% fewer incomplete answers, 13% fewer missed key aspects, and 5.4% lower token usage. The tradeoffs: automation requires strict guardrails, and weak evaluation signals risk brittle improvements.

Testing cookie behavior across hundreds of web surfaces with our in-house auditor

Dropbox describes an in-house cookie auditor built with Playwright that simulates privacy-conscious visitors (US, EU, and Global Privacy Control signals) across 200+ web surfaces, verifying consent choices persist and only appropriate cookies load. The article argues browser automation was the easy part; most effort went into translating legal concepts into testable rules, maintaining a current URL inventory via traffic-data analysis, and separating real violations from false positives. Classifications live outside the code so privacy staff can update rules without engineering releases.

How well do agents use test/verification techniques?

An empirical eval of 26 prompt conditions (TDD, fuzzing, property-based testing, formal methods, and testing skills) given to coding agents implementing Zstd in Rust, ~80 runs each. Nothing beat the default no-instructions baseline; agents apply techniques superficially—vacuous proofs, trivial random tests—while TDD and popular testing skills underperformed. A brief hand-written skill nudging risky-area checks and structured randomization scored best, suggesting expert guidance matters more than naming techniques.

There's no point at which turning your brain off will work

The author argues that 'brain-off' LLM use—having agents write code and just relaying failures back (being a 'meat proxy')—still produces poor-quality software, failing on out-of-distribution problems and overfitting to tests or metrics. Even if it eventually yields good software, it won't benefit the employee, since a company could run the LLM loop without them and lay them off. He contends the present is the worst time to disengage, as companies are eager to cut low-contribution roles.

Astra for Coding: Why Are We Doing This Again?

The author ran a fully autonomous 'software factory' with GPT 6 Astra for 35 hours (~$1200, 79 commits, 75k lines of code) and got nothing usable. His core complaint is that the model's token-efficient 'codegolf' Python for tool calls leaks into committed code, producing unreadable and bizarre output, and that it won't stop on oversized tasks. He argues training rewards local metrics over human readability, and doubts these costlier models still fit day-to-day software engineering versus other use cases.