← All speakers

Bio, Work & Ideas

Cat Wu

Conference affiliation: Head of Product, Claude Code · Anthropic · 2026

On this page

Cat Wu is Anthropic’s head of product for Claude Code and product lead for Cowork. She builds products for delegating software development and knowledge work to AI, while continually testing whether new models have made yesterday’s product constraints obsolete. Her repeated experiment—asking successive models to add a table tool to Excalidraw—captures that approach: months of failures eventually became a feature the team could demonstrate live.

Engineering, investing, and hands-on product work

Based in San Francisco, Cat worked as a product engineer at Scale AI from 2018 to 2020, building products and scaling operations for enterprise customers. As an engineering manager at Dagster Labs in 2020–2021, she led the creation of its first commercial product, from ideation through onboarding alpha users. She then became a partner at Index Ventures, working there from October 2021 to August 2024. Investing still involved programming: she built tools to scan X for new-company announcements and detect open-source projects gaining momentum.

Cat joined Anthropic in August 2024 on the Research PM team, connecting model research with customer needs. When Claude Code became available internally that fall, she used it to build Streamlit applications for analyzing user feedback, run evaluations to explore which benchmarks the company should trust, and create reinforcement-learning environments to understand training. In her first-person account of AI product management, she describes hundreds of hours spent prompting those projects without writing their code by hand.

Her Excalidraw experiment began in October 2024. Each new model got further but still failed; Opus 4 began succeeding occasionally, and by Opus 4.6 the team felt comfortable attempting the task live before professional developers. Repeating the same request gave Cat a practical measure of progress. It also challenged a familiar planning assumption: what is technically possible at the beginning of a project may change substantially before it ships.

Prototypes, changing capabilities, and fewer workarounds

Cat describes a team where designers ship code, engineers make product decisions, and product managers build prototypes and evaluations. Clear strategy gives people direction without requiring every experiment to pass through a sequence of handoffs. She has also had to adjust her own expectations. A self-described perfectionist, she writes that relinquishing tight control over the whole experience was difficult; her response is to identify the few requirements that are truly non-negotiable and leave more room elsewhere for iteration.

Several decisions make her approach concrete:

  • Use working software to test the idea. Short experiments give colleagues and customers an experience to try before the team commits to a long plan. Cat describes Claude Code on Desktop, todo lists, and AskUserQuestion as features that emerged from self-directed team experiments. Demos with genuine internal engagement earn further polish and wider release.
  • Establish capability before cutting costs. Cat argues that limiting tokens too early can make a feasible feature appear unworkable. Early prototypes should reveal whether an agent can perform the task well; cheaper models and implementations can follow once the team understands what works.
  • Remove workarounds when models outgrow them. Claude Code initially needed periodic reminders to update its todo list. When a later model handled that behavior reliably, the team removed the reminders. Simple implementations make it easier to absorb capability improvements without retaining machinery built for an earlier limitation.
  • Recognize product opportunities in user handoffs. Users were building web applications with Claude Code, then manually passing instructions to Claude in Chrome to test them. That repeated transfer suggested a built-in connection. Cat’s July 2026 post about the desktop browser describes another way to bring website interaction into the coding workflow, including opening the production application an agent is helping someone build.

Coordinating agents and evaluating delegation

In the public conversation with Thariq Shihipar and Simon Willison, the Anthropic team describes Claude Tag as a shared agent in Slack. Colleagues can steer the same task, retain channel-specific preferences, and ask it to monitor bug reports proactively. A first implementation can move through product, design, and engineering in one shared conversation rather than separate sessions.

The discussion also illustrates how usage can overturn product intuition. Remote Control connects a phone or browser to a local Claude Code session. Cloud sessions initially seemed sufficient to one participant, but users valued keeping their own laptop environment available while directing work from the couch. The team began leaning into that routine after seeing how people used it.

Cat’s own September 2026 description of Projects makes her preferred delegation workflow clear: assign a batch of tasks, move on, and ask for an aggregated status update while shared memory evolves. The initial Projects beta connected a coordinating conversation with parallel cloud sessions and shared memory. Each thread worked on its own branch and repository copy; overlapping changes still required merge-conflict resolution. The launch was limited to select Pro and Max users, rather than immediately available to everyone.

This also marked a change from the three-part workflow Cat described in March: chat for thinking, Claude Code for code, and Cowork for other tasks. Anthropic’s September unification of Cowork and chat addressed users’ frustration with choosing where a task belonged and carrying context between products.

The team’s panel discussion distinguishes correct implementation from successful delegation. An agent can pass tests yet frustrate someone by stopping after completing only part of an assignment. Behavioral evaluations target those interruptions, while incident-causing pull requests become regression cases for code review. Human code owners continue reviewing critical changes as automated review gradually takes on more responsibility elsewhere.

Instructions and tools require similar care. The discussion questions unconditional verification rules for trivial interface edits and explains why a dedicated file-edit tool remains useful: it lets the product recognize a file change and display an approval interface. These are decisions about matching guidance and interaction to the task, rather than simply adding more instructions or tools.

Anthropic’s auto mode supports longer autonomous work by checking proposed tool actions for destructive operations, prompt injection, and data exfiltration. The company acknowledges residual risk and recommends human scrutiny for high-stakes production changes. This is a team-developed safeguard; Cat is acknowledged in the article, whose author is Conner Phillippi.

A climber’s custom software

Outside work, Cat is a rock climber. She and her friends built a climbing-project tracker with Claude Code, and she uses agent workflows to research trips around their climbing grades, flight options, accommodation, and walking distance from the car to the rock. She dislikes long approaches, so that preference becomes an explicit research constraint. Instead of manually clicking through climbing listings and travel services, she can request a custom map organized around the group’s needs.

Read the topics behind these talks

1 conference talk

Key ideas

Scroll to read ↓

Cat Wu, Thariq Shihipar, and Simon Willison explore how stronger coding agents change product judgment, team collaboration, review, prompting, and the security needed for sustained autonomy.

  • Fable returns, and expectations rise
    0:28 ↗
  • Product judgment and the economics of rewrites
    3:49 ↗
  • A shared agent inside the team’s conversation
    6:35 ↗
  • Let usage challenge product intuition
    11:35 ↗
  • Earn automated review one area at a time
    14:18 ↗
  • Evaluate both capability and behavior
    17:16 ↗
  • Give capable models context without overconstraining them
    20:19 ↗
  • Models write prompts, and prompts explain products
    25:28 ↗
  • Keep tools distinct, and preserve useful interfaces
    28:03 ↗
  • Auto Mode evaluates permission in context
    30:57 ↗
  • Shared agents need separate identities and protected secrets
    35:01 ↗
  • Find the larger project and fill the missing role
    37:53 ↗
  • An editing task that required judgment
    41:49 ↗
  • Following a specification is not the whole design task
    43:35 ↗
  • Make context accessible and test imagined trade-offs
    45:07 ↗
  • Eval quality and the concrete shape of shared memory
    49:20 ↗

References