ClaudeHow the Claude Code team uses Claude Code
CHAPTERS
- 0:00 – 0:35
A year of change: from hand-holding tool calls to delegating real goals
The conversation opens with the team reflecting on how quickly their workflows have evolved over the past year. They describe a shift from closely supervising every model action to delegating higher-level goals and letting agents handle complexity.
- •Planning horizons feel compressed—“hard to think about the next two months”
- •Early Claude Code usage involved lots of prompting, feedback, and permissions
- •Today’s work is framed around goals rather than individual tool calls
- •The team has rapidly expanded what they trust agents to do
- 0:35 – 2:22
Claude Tag in Slack becomes the team’s default work surface
Robert and Sid explain that most of their day-to-day work now happens through Claude Tag in Slack. Slack-native context (product discussions, decisions, history) improves agent decision-making and enables more complex tasks than early “write a function” prompts.
- •Robert uses Claude Tag for larger, more ambiguous problems
- •Slack context helps the agent incorporate product intent and team decisions
- •Sid estimates 70–80% of his work happens in Claude Tag
- •The team has moved from transcript obsession to outcome-focused delegation
- 2:22 – 3:14
Building on AI that shifts every two months: designing for obsolescence
They compare traditional software stacks (stable for years) with AI model capabilities that change every couple of months. The team discusses the tension between shipping value now and staying ahead of the frontier as the underlying technology constantly moves.
- •Model capability upgrades compress the “shelf life” of product techniques
- •Teams must balance frontier exploration with practical user value
- •Engineers need an evolving mental model of what Claude can do
- •Claude Code is described as a “hyperbolic time chamber” for software evolution
- 3:14 – 5:39
Catching waves with the right primitive: to-do lists, failure modes, and letting go
Sid shares how to-do lists emerged as a key workaround when models struggled with long-horizon tasks—then quickly became unnecessary. The team frames many Claude Code features as temporary scaffolding that covers current model failure modes and gets replaced as models improve.
- •To-do lists helped early models complete multi-step work reliably
- •Techniques can become obsolete within a year (or sooner)
- •Successful building requires being “unattached” to what you ship
- •As models improve, teams can delete old scaffolding and pursue bigger tasks
- 5:39 – 6:43
AskUserQuestion → artifacts: making interaction natural as capabilities improve
They recount the design of AskUserQuestion as a step toward interactivity, and how hard it was to get the model to call it well. Over time, artifacts (interactive HTML with diagrams/mockups) began to replace explicit question tools, illustrating how primitives evolve as models get more capable.
- •AskUserQuestion started as a post-planning step, then became a callable tool
- •Designing the tool to be used correctly was unexpectedly difficult
- •Artifacts increasingly handle interactive clarification via UI and structure
- •The team’s approach: build primitives that can be layered and recomposed
- 6:43 – 8:13
Why loops moved to the cloud: persistence, remote devboxes, and routines
Sid explains the practical journey from running agents locally (and losing work when closing a laptop) to remote hosted environments. This drove the creation of Claude Code on the web with long-running containers, enabling persistent loops and scheduled routines.
- •Local-only agents break when developers go offline or close laptops
- •Remote devboxes helped but added friction (SSH, context switching)
- •Hosted containers made long-running Claude sessions practical
- •Setup friction exists (granting access to dev environments) but pays off
- 8:13 – 8:52
Routines that act above the chat session: continuous triage and bug-fixing
With Claude running persistently in the cloud, the team can schedule routines that monitor feedback, bucket issues, and fix what’s high-confidence. This represents a shift from one-off chat sessions to systems that operate continuously and autonomously on a developer’s behalf.
- •Daily routines can summarize feedback and prioritize fixes
- •“Breaking the boundary of a session” enables higher-level prompting
- •Loops can execute ongoing maintenance, not just interactive assistance
- •This is framed as the broader “loop journey” the team is pursuing
- 8:52 – 11:11
Code review changes: humans stop nitpicking and focus on architecture intent
Robert describes how Claude reshapes code review by handling minor issues automatically and guiding humans to the highest-leverage concerns. Human reviewers can spend time on architectural rationale and API boundaries instead of performative line-by-line nitpicks.
- •Traditional reviews often include nitpicks to signal “I read it”
- •Claude can autonomously find and address low-level issues
- •Human attention shifts to system boundaries, API structure, and intent
- •Claude can surface relevant context to support better human judgment
- 11:11 – 14:04
Workflows from code review: fan-out, adversarial verification, and MapReduce thinking
Sid explains that their workflow system grew out of large-scale code review fan-outs, followed by adversarial checks to validate which issues are real. They generalize the pattern to research, performance, and planning—using test-time compute to filter and build confidence from overwhelming information.
- •Massive fan-out finds many candidate bugs or options
- •Adversarial “multi-perspective” review filters false positives
- •The pattern generalizes (performance issues, deep research, trip planning)
- •MapReduce analogy: fan out, then coalesce for human consumption
- •Deterministic orchestration code (loops) increases trust and reliability
- 14:04 – 16:13
Building Claude Tag with Claude Tag: decoupling UI from transcripts and “letting Claude cook”
Robert describes using Claude Tag aggressively to build Claude Tag itself, focusing on a smooth dev loop for agents. They explain a major UI shift: Slack messages are tool-mediated outputs while the full transcript is secondary, which feels scary at first but enables a more outcome-driven workflow.
- •Primary goal: make Claude Tag capable of developing and testing itself end-to-end
- •As integration complexity rises, the agent-friendly dev loop matters more
- •Slack UI is one abstraction level above raw tokens and tool call details
- •Reduced transcript visibility forces trust and encourages delegation
- •Models are now good enough to deliver strong results without micromanagement
- 16:13 – 19:26
Verification + feedback loops in Slack: events, monitoring, and funnel optimization
Thariq shares an end-to-end example of using Claude Tag to drive stakeholder discovery, mockups, implementation, deployment, and monitoring—directly within Slack. The team highlights verification, code review, and feedback ingestion (events/metrics/issues) as core primitives that enable confident iteration.
- •Claude Tag helps identify stakeholders and generate mockups in Slack
- •Instrumenting events enables real-world usage monitoring and iteration
- •Claude can proactively surface feedback by tagging the developer
- •Verification, code review, and feedback ingestion are core Claude Code primitives
- •PR verification includes tests and screenshots to build confidence
- 19:26 – 22:22
What they miss from the old craft—and what replaces it: depth vs velocity and accessible creation
They close by reflecting on what’s lost as Claude takes over detailed craft work (performance tuning, pixel-perfect UI fiddling) and what’s gained (faster idea-to-production loops). The team frames modern software engineering as continual change, with problem-solving remaining the core skill despite rapidly shifting tools.
- •Robert misses hands-on performance engineering, but benefits from faster improvements
- •Attention shifts from deep weeds to generating and shipping ideas faster
- •Detailed UI craft becomes optional as Claude can replicate complex designs quickly
- •Claude makes software creation feel broadly accessible—closer to pure ideation
- •Despite faster change, the job remains fundamentally about problem-solving
