Simon Willison

The Death of the Waterfall Spec For decades, software development followed a predictable, glacial rhythm. Product managers spent months gathering customer feedback, drafting exhaustive Product Requirement Documents (PRDs), and aligning cross-functional stakeholders. Only after everyone signed off on a static specification would engineers begin writing the first line of code. Cat Wu, Head of Product for Claude Code at Anthropic, argues that this traditional playbook is officially dead. The emergence of highly capable coding agents has compressed the time between an abstract idea and a functional implementation from months to days—sometimes even hours. This shift does not make software engineering obsolete. Instead, it redefines the role. When execution becomes cheap and fast, the premium shifts from raw coding speed to product taste and business sense. Developers must evolve from pure implementers into product thinkers who understand what is worth building in the first place. The Paradoxical Rise of the Healthy Rewrite One of the oldest rules in software development is "never do a rewrite." In the pre-agent era, rewriting a functional codebase was a notorious recipe for introducing regressions, blowing past deadlines, and sinking companies. The existing codebase often served as the only accurate specification of how the system actually functioned, hidden beneath layers of undocumented edge cases. Thariq Shihipar, a software engineer working on Claude Code at Anthropic, suggests that this fundamental rule has inverted. Armed with robust test suites and agentic tools, developers can now treat rewrites as a standard design pattern. An existing codebase can be fed into an LLM as an artifact to be distilled, optimized, or completely ported to another language. The Anthropic team put this into practice by rewriting substantial portions of their own tooling. A strong test suite acts as the guardrails for this process. It forces the developer to verify the behavior of the agent while allowing the model to quickly generate clean, performant implementations that are far easier to maintain than legacy code. How Claude Tag Drives Multiplayer Automation While individual developer tools like Claude Code focus on single-user, interactive loops, modern software development is fundamentally a team sport. To bridge the gap between solo "vibe coding" and team collaboration, Anthropic launched Claude Tag, a proactive agent built directly into team collaboration platforms like Slack. Unlike traditional reactive chat bots that only respond when directly mentioned, Claude Tag operates proactively. Teams can instruct the agent in natural language to monitor specific Slack channels for bug reports, automatically generate a Pull Request (PR) to fix the issue, and tag the engineer who last touched that specific section of the codebase. This workflow has completely transformed Anthropic's internal velocity. Wu revealed that their internal version of Claude Tag now lands 65% of all product PRs for their product engineering team. This high level of automation is supported by team-level memory features. If a developer instructs the agent to handle outages differently than standard warnings, it remembers those preferences across all future sessions in that channel, storing the configuration in simple markdown files. Rethinking Prompts for Next-Generation Models For years, the gold standard of prompt engineering was simple: use few-shot examples. Providing an LLM with structured inputs and desired outputs was the most reliable way to enforce formatting and maintain quality. However, as models have advanced, this conventional wisdom has broken down. Shihipar revealed that the system prompt for Claude Code was reduced by 80% for frontier models like Claude 3.7 Sonnet and the Fable-class models. This massive reduction was achieved by stripping out rigid few-shot examples and overly restrictive "do not" rules. The Anthropic team discovered that providing examples actually constrained the model's creativity. Frontier models possess a level of native judgment and contextual awareness that allows them to make smart assumptions based on minimal guidance. Instead of instructing a model to "always verify front-end changes," the updated prompt relies on the model's discretion to decide when a quick string replacement can skip verification and when a complex UI change requires running the app locally. Stripping away the guardrails allows the model to find cleaner, more creative solutions to complex engineering challenges. Building Trust via Continuous Evals and Auto Mode Handing over the keys of a production codebase to an AI agent can feel terrifying. Security risks like prompt injection, where malicious external inputs hijack an agent's execution loop, are real. To address this, Anthropic relies on Auto Mode, a feature designed to handle long-running agentic tasks safely. Auto Mode relies on a dedicated classifier that constantly monitors the conversation context, the tool calls, and user instructions. It dynamically evaluates permissions rather than relying on binary, static rules. If a user instructs the agent to push code to GitHub, Auto Mode allows the action; if the request comes from an unverified external source, it blocks it. To deploy these agents internally with confidence, Anthropic invested over six months into building an extensive suite of both external and internal evals. When an incident occurs, the team reviews the PR that caused the failure, writes a test case to prevent it, and adds it to their continuous integration suite. This ensures that new models act as drop-in replacements, guaranteeing they are strictly better and safer than their predecessors before they ever touch production infrastructure.