Claude Fable, Claude Tag, and Anthropic's Culture

🎤 Speakers

🎯 Key Themes

💡 Key Takeaways

The panel opens with introductions at the AI Engineer conference. Cat Wu leads product for Claude Code at Anthropic. Thariq Shihipar is an engineer on the Claude Code team. Simon Willison, creator of Datasette and co-creator of Django, serves as moderator — bringing his own deep experience with AI coding tools to the conversation.

The conversation is framed as a long-form exploration of how coding agents have evolved and what comes next — covering everything from day-to-day workflows to organizational culture changes.

Coding agents like Claude Code have fundamentally reshaped how developers spend their time. The shift is away from manual low-level implementation — writing every line of code, debugging syntax, tracing through call stacks — toward higher-level product strategy.

Developers are increasingly operating as orchestrators: defining what needs to be built, reviewing agent outputs, and iterating on the product direction. The day-to-day feels less like a craftsman shaping every detail and more like a creative director managing an increasingly capable collaborator.

Traditional software engineering practices are being disrupted. The panel discusses how practices like avoiding rewrites at all costs or long-term waterfall-style planning are becoming outdated in the age of AI coding agents.

The new emphasis is on:

The role of a developer is evolving toward someone who deeply understands the what and why of a product, rather than just the how. Implementation skill is still valuable, but product intuition is becoming the rarer, more important capability.

This is one of the most paradigm-shifting points in the discussion. Historically, rewrites were seen as dangerous, expensive, and usually a bad idea — Joel Spolsky's famous essay "Things You Should Never Do" warned against them.

With AI coding agents, the calculus has completely changed. Rewrites are now cheap and fast. Instead of painstakingly maintaining legacy code with accumulated technical debt, you can rewrite components quickly and confidently.

This inverts decades of conventional wisdom about software maintenance and represents a genuine shift in how we should think about code ownership and longevity.

Claude Tag represents a major evolution: the shift from single-player coding agent to multiplayer, proactive agentic workflows. Operating inside Slack, Claude Tag doesn't wait to be asked — it proactively:

• Monitors bugs as they're reported in channels
• Drafts pull requests to fix issues autonomously
• Retains team memory across conversations and contexts
• Collaborates asynchronously with the development team

This statistic is staggering. It means the majority of code changes shipping to Anthropic's products are initiated and completed by an AI agent working alongside the team. The human role shifts to review, direction-setting, and handling the edge cases that require deeper judgment.

Anthropic practices aggressive dog-fooding — using Claude Code and Claude Tag extensively for their own development work. This isn't just a nice-to-have; it's a core part of how they prioritize features.

When the team hits friction with their own tools, those pain points get escalated and fixed quickly. The feedback loop is incredibly tight: use → find friction → fix → use again. This explains why Claude Code has evolved so rapidly — the development team is simultaneously its most demanding user base.

One of the more surprising revelations: remote control and monitoring capabilities became unexpectedly popular. Developers want to kick off a long-running agent task, then check on it from their phone.

This speaks to a fundamental shift in how developers relate to their work. Instead of being tethered to a terminal, watching code execute line by line, they can delegate to an agent and monitor asynchronously — from a phone, a coffee shop, or another context entirely.

Code review is changing fundamentally when the "author" is an AI agent. The focus of review shifts — you're not checking for typos or style consistency (the agent handles that). Instead, review focuses on:

• Architectural decisions — did the agent choose the right approach?
• Edge cases — are there scenarios the agent didn't consider?
• Test coverage — are the tests actually testing the right things?
• Product correctness — does this solve the actual user problem?

Automated testing becomes even more critical in this world. The review process needs to evolve alongside the tools — and teams that don't adapt their review culture will either slow down or ship bugs.

Each new model generation requires teams to rebuild trust from scratch. A workflow that worked well with one model version might behave differently with the next — sometimes better, sometimes in unexpected ways.

The panel emphasizes the critical role of evaluations (evals) in this process. Before deploying a new model, teams need systematic ways to validate behavior. This isn't just about benchmarks — it's about understanding how the model handles the specific patterns and edge cases your codebase presents.

A crucial tension in building AI tools: raw model capability vs. user experience. The best model in the world is useless if the UX makes it hard to use effectively.

Product design matters as much as model performance. The team discusses how they balance pushing capability boundaries while ensuring the tool remains intuitive, predictable, and pleasant to use day-to-day. Great AI tools need to feel like an extension of the developer's intent, not a black box requiring careful prompting.

A counterintuitive finding: as models get smarter, you need less prompting. Over-engineering system prompts can actually hurt performance with frontier models.

This has practical implications for anyone building on top of these models. The instinct to add more instructions, more guardrails, more specific guidance often backfires. A simpler, cleaner prompt gives the model room to apply its full capability — and often produces better results.

How should tools be designed for AI agents? The panel dives into the principles of good tool API design in an agentic context. Key principles:

• Clear interfaces — tools should have unambiguous inputs and outputs
• Good documentation — the agent needs to understand what a tool does and when to use it
• Predictable behavior — surprising edge cases confuse agents just as much as humans
• Composability — tools that combine well enable more complex workflows

The design of tool APIs directly impacts agent performance. A well-designed tool interface can be the difference between an agent that struggles and one that executes flawlessly.

One of the most substantive segments of the panel. Auto Mode — where Claude Code runs with greater autonomy for extended tasks — is Anthropic's recommended approach for long-running agentic work.

But autonomy requires safety. Anthropic has invested heavily in:

• Comprehensive evals — systematic testing of model behavior in agentic contexts
• Red-teaming — adversarial testing to find vulnerabilities
• Prompt injection mitigations — defending against malicious inputs
• Data exfiltration prevention — ensuring agents don't leak sensitive information

Perhaps the most motivational segment. The panel encourages developers to be dramatically more ambitious about what they build.

The panel challenges developers to stop thinking in terms of what's "reasonable" given traditional resource constraints. Implementation is now the cheap part. Vision, product sense, and ambition are the scarce resources.

Build the thing that seemed impossible. Build the thing you would have dismissed as too resource-intensive. The economics of software have changed — act accordingly.

Claude is being used far beyond traditional coding tasks. The panel shares unexpected use cases that have emerged:

These use cases highlight how the tool has expanded far beyond its original "coding assistant" framing. When implementation is cheap, creative applications multiply.

Looking forward, the panel discusses models becoming better interaction design partners. The future isn't just about writing code — it's about bridging the gap between abstract ideas and production-ready software.

Aspirations include models that natively understand:

• Design and UX principles — not just implementing a design, but suggesting better ones
• Product strategy — understanding user needs and market context
• System architecture — making good infrastructure decisions at scale

The gap between "I have an idea" and "it's live in production" is shrinking rapidly. The future the panel envisions is one where that gap is nearly zero for most applications.

The panel shares concrete team culture tips from inside Anthropic on how to structure teams around agentic workflows:

• Embrace the new reality — don't try to fit AI tools into old workflows
• Restructure review processes — optimize for agent-generated code review
• Invest in test infrastructure — tests become even more critical when agents write code
• Encourage experimentation — let people explore new agentic workflows without judgment

The cultural shift is just as important as the technical one. Teams that cling to pre-AI workflows will be outpaced by those that adapt their culture to leverage these new capabilities.

The panel wraps up the structured discussion with fun demos and side projects — showing what's possible when implementation cost approaches zero. These projects serve as both entertainment and inspiration, demonstrating that the technology enables an entirely new class of creative expression.

When building things is nearly free, the only question is: what do you want to exist?

The session closes with live questions from the AI Engineer conference audience, covering practical concerns about adoption, team dynamics, and the future trajectory of agentic development tools.