Linklog

Anthropic’s collection of runnable guides for building with Claude: tool use, RAG, structured extraction, multi-agent orchestration, extended thinking, prompt caching, batching, and deployment patterns. Worth remembering as the first place to look for a working example of an API feature before writing one from scratch.

Haggai Roitman’s practitioner’s guide to agentic AI, covering the whole stack on the argument that building good agentic systems requires understanding every layer: transformers, GPU infrastructure and training at the bottom, then alignment and reasoning (RLHF, DPO, chain of thought), RAG and memory architectures, agent design patterns, multi-agent coordination, and evaluation and deployment at the top. Each chapter pairs theory with code examples and references. Bookmarked as a reference to dip into rather than read cover to cover.

A browsable queue of Wikipedia rabbit holes and evergreen YouTube videos that have been popular on Hacker News.

Satya Nadella used the term “cognitive coverage” on Hard Fork to describe how much of the code a developer understands when they commit it. Basically the flip side of cognitive debt, with a nice parallel to test coverage.

Jason Swett argues that agents only write useful tests if they are given a concrete process to follow. Models may know about TDD in the abstract, but they default to vague, performative, or overcomplicated tests.

Basing the agent loop on “specify, encode, fulfil” gives the agent an executable target, keeps speculative implementation (code/feature bloat) in check, and makes refactoring easier to review.

Addy Osmani separates cognitive offloading (delegating while keeping your own judgment) from cognitive surrender (accepting AI output without forming an understanding of your own). Engineers are unusually exposed: code looks correct by default, and productivity metrics can’t tell understanding from approval. The habit compounds into what he calls comprehension debt. His countermeasures are small and practical: form an expectation before reading the output, read diffs critically, ask the model for counter-arguments, and notice when fatigue is making you rubber-stamp.

Another name in the growing vocabulary around cognitive debt and cognitive coverage.

John Smart’s Transcension Hypothesis proposes that advanced entities or civilisations may not expand outward across the standard universe indefinitely. Instead, they may transcend our observable frame by moving inward toward denser, more computationally efficient, or more information-rich domains.

David Oks argues that AI job loss will be slower and less sudden than the current panic suggests. His case is that humans and AI will stay useful together for a long time, because real work has bottlenecks, demand grows when things get cheaper, and society adapts more slowly than models improve.

Computers required complementary investments that took years or decades to develop: new business processes, organisational restructuring, worker retraining, new management practices. It took until the 90s to see any macroeconomic productivity impact

Annie Vella on a Thoughtworks retreat about the future of AI-driven software development. People are starting to name the questions around cognitive load, trust, platform foundations, agent governance, and the changing shape of engineering work. The key lesson for her was “Nobody has this figured out”

A nice description of the anatomy of a harness with the memorable formula Agent = Model + Harness

Simon Willison points to Margaret-Anne Storey’s useful framing of cognitive debt: the loss of shared understanding when AI helps teams move faster than they can explain. The code may work, but the team can still lose the plot.

A case study in agentic engineering at scale: for five months an OpenAI team shipped an internal product with zero manually-written lines of code.

Every line, application logic, tests, CI, docs, observability and tooling, was written by Codex, across roughly a million lines and 1,500 merged PRs from a small team.

They estimate a 10x speedup over hand-written code.

Dan Shapiro’s scale for AI coding automation: level 1 offloads small tasks, level 2 pairs with an AI-native coding tool, level 3 manages agents through diffs, level 4 delegates from specs and plans, and level 5 is the dark factory where specs go in and software comes out.