The Claude Code team now completes 70% to 80% of daily engineering through Claude Tag in Slack, transitioning from terminal micro-prompting to assigning high-level objectives powered by ambient workspace context. (0:35)
Underlying foundation model capabilities now shift every two months, compelling the team to treat agent scaffolding—such as explicit to-do list harnesses—as disposable patches to delete once models improve natively. (2:17)
Decoupling execution from local laptops into persistent cloud containers yielded an estimated 10x productivity boost, unlocking persistent autonomous routines that continuously monitor telemetry and deploy bug fixes. (6:41)
Automated code review has adopted test-time compute through MapReduce workflows, where dynamic fan-out sub-agents and adversarial reviewers pre-screen pull requests to surface only high-signal architectural questions to humans. (10:42)
Detailed notes
## Background
Published on YouTube by the official Claude channel on September 2, 2026, this discussion features Claude Code team members Thariq Shihipar, Sid Bidasaria, and Robert Boyce. According to the video description, the engineers break down how their daily workflows evolved from manual terminal micro-prompting and permission granting into an asynchronous, goal-oriented paradigm powered by Slack-based agents, hosted routines, and dynamic workflows.
## TL;DR
The Claude Code team details how their internal development process transitioned from micromanaging isolated code generations to assigning high-level objectives through Claude Tag in Slack, which now accounts for roughly 70% to 80% of their daily engineering work. Because underlying frontier models evolve every two months, the team maintains an aggressive harness philosophy of deleting scaffolding—such as explicit to-do lists—as soon as native model capabilities render them obsolete. Development has largely moved off local laptops into cloud containers, enabling long-running background routines and MapReduce-style fan-out workflows with adversarial sub-agents for code review. Ultimately, the engineers explain how this shift frees human mental bandwidth from line-by-line syntax pedantry, elevating their role toward architectural verification and high-level product design.
## Atmosphere & style
The conversation carries a relaxed, introspective, and pragmatic tone, feeling like an authentic peer-to-peer engineering postmortem rather than a scripted promotional piece. The dynamic among Thariq, Sid, and Robert is candid and collaborative as they chuckle over the absurdities of early agent development—such as walking across parking lots with open laptops to prevent agents from stopping. A gentle emotional arc blends excitement about massive productivity gains with genuine nostalgia for the lost tactile joys of programming, from hand-crafting CSS Aqua buttons to profiling performance bottlenecks, before ultimately reconciling that change with a childlike sense of uninhibited creative potential.
## Bulletin
- [00:35](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=35s) The Claude Code team now completes 70% to 80% of daily engineering through Claude Tag in Slack, transitioning from terminal micro-prompting to assigning high-level objectives powered by ambient workspace context.
- [02:17](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=137s) Underlying foundation model capabilities now shift every two months, compelling the team to treat agent scaffolding—such as explicit to-do list harnesses—as disposable patches to delete once models improve natively.
- [06:41](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=401s) Decoupling execution from local laptops into persistent cloud containers yielded an estimated 10x productivity boost, unlocking persistent autonomous routines that continuously monitor telemetry and deploy bug fixes.
- [10:42](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=642s) Automated code review has adopted test-time compute through MapReduce workflows, where dynamic fan-out sub-agents and adversarial reviewers pre-screen pull requests to surface only high-signal architectural questions to humans.
## Key takeaways
- [00:00](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=0s) Interacting with Claude Code has migrated from granular terminal prompts and constant permission approvals to goal-driven asynchronous workflows in Slack.
- [00:35](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=35s) Operating natively in Slack provides the agent with ambient team discussions and architectural context, significantly improving autonomous decision-making.
- [02:17](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=137s) Frontier models change fundamentally every two months, forcing engineers to discard code and remain detached from custom harness features as models outgrow them.
- [02:17](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=137s) Scaffolding like explicit to-do list tracking was critical to patch Sonnet 3.5's execution limits, but was deleted within a year once native state-tracking caught up.
- [04:48](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=288s) The evolution from the brittle AskUserQuestion tool to interactive HTML visual artifacts illustrates how quickly agent interaction primitives become obsolete.
- [06:41](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=401s) Migrating off local developer laptops into hosted containers allowed long-running background routines to operate persistently across issue triage and deployment.
- [09:09](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=549s) Human code review has shifted from manual nitpicking and proof-of-work comments toward high-level evaluation of service boundaries and API designs.
- [10:42](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=642s) MapReduce test-time compute workflows deploy fan-out agents and adversarial verification to filter out false positives before human review.
- [10:42](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=642s) Claude autonomously writes deterministic orchestration code, such as standard loops, to reliably coordinate sub-agent verification graphs.
- [14:04](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=844s) Decoupling the Slack user interface from Claude's internal token stream liberated developers from micro-managing intermediate steps and allowed agents uninterrupted execution.
- [16:13](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=973s) End-to-end autonomous loops now handle stakeholder alignment, implementation, telemetry logging, funnel analysis, and multi-modal verification via recorded screen interactions.
- [18:25](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=1105s) The hardest modern engineering shift is shedding low-level code micromanagement in favor of continuous high-level architectural orchestration and automation design.
- [19:18](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=1158s) While engineers feel nostalgia for the meditative craft of manual optimization and styling, AI eliminates syntactic blockers to restore direct, frictionless prototyping.
## Detailed walkthrough
### [00:00](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=0s) From Micromanagement to High-Level Goals in Claude Tag
Reflecting on the past year of building and using Claude Code, the team admits it is nearly impossible to forecast where things will be in twelve months when planning even two months ahead is an exercise in uncertainty. Just a year prior, interacting with Claude Code was a painstaking, hands-on process centered around micro-prompting, providing immediate conversational feedback, and constantly approving terminal permission prompts. Today, that manual interaction has been largely superseded by Claude Tag, a Slack-native agent where engineers now direct the overwhelming majority of their day-to-day work. The nature of the problems handed to Claude has transformed in kind; instead of asking the model to implement an isolated class or write a standalone utility function, the team entrusts it with far broader, multifaceted problems.
Because Claude Tag lives directly in Slack, it possesses immediate access to rich, ambient product context—such as ongoing discussions, rationale behind team architectural choices, and organizational decisions about product scope. Having access to that operational history allows the agent to make significantly better engineering choices. Roughly 70% to 80% of engineering work now takes place asynchronously in Claude Tag, with engineers reserving the terminal user interface (TUI) or desktop client for the remaining 20% of tasks where they need to quickly refine a detail or deliberately "micromanage" the model. Software development has moved away from hyper-fixating on session transcripts, parsing individual tool invocations, and auditing every tactical decision toward a high-level model: simply defining a goal and granting the model the agency to achieve it across verification, code review, brainstorming, and monitoring.
- **Primary development surface:** 70% to 80% of day-to-day software development occurs in Claude Tag within Slack, leaving only 20% to local TUI or desktop workflows for tactical refinement.
- **Context richness:** Slack integration feeds internal product decisions and team conversations directly into the agent’s reasoning loop.
- **Workflow paradigm shift:** Moving from inspecting individual tool calls and class-level generation to assigning end-to-end operational objectives.
```mermaid
flowchart TD
accTitle: Evolution of Claude Code Interaction Paradigms
accDescr: Diagram illustrating the shift from manual terminal prompt sessions to autonomous Slack-native goal execution.
subgraph Legacy["Legacy Workflow (1 Year Ago)"]
direction TB
A["Manual Micro-Prompts"] --> B["Step-by-Step Tool Calls"]
B --> C["Continuous Permission Prompts"]
end
subgraph Modern["Modern Workflow (Claude Tag)"]
direction TB
D["High-Level Engineering Goal"] --> E["Slack Ambient & Product Context"]
E --> F["Autonomous Execution & Verification"]
end
Legacy -.->|"Paradigm Shift"| Modern
```
[02:17](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=137s) Building on Technology That Shifts Every Two Months
Developing software on top of frontier AI introduces an unprecedented structural challenge: whereas traditional infrastructure or software platforms enjoy a multi-year shelf life, the underlying capabilities of foundation models shift fundamentally every two months. That compression of time forces the team into a delicate balancing act that is part art and part science: pushing past the current frontier to explore the bleeding edge while simultaneously delivering robust, practical value on current models.
This rapid velocity demands extreme detachment from the harness code being written. During the Sonnet 3.5 era, for instance, models struggled severely with long-horizon execution; assigning five subtasks routinely resulted in the model completing three and abruptly halting. To compensate, the team engineered explicit to-do list scaffolding into the Claude Code harness, which dramatically improved task completion at that moment in time. Yet barely a year later, as underlying models developed sophisticated internal memory and state-tracking capabilities, the to-do list harness became redundant and was promptly discarded. The Claude Code team views harness engineering as an ongoing process of temporarily patching current model failure modes, freely deleting scaffolding as the frontier advances, and designing fresh tools suited for larger problem scopes.
- **Technology shelf life:** Historically measured in years, the core underlying model technology now radically shifts every two months.
- **The "Ride the Wave" example:** The to-do list feature was created to solve Sonnet 3.5's inability to sustain long-horizon execution beyond three subtasks, but was completely phased out within a year.
- **Harness philosophy:** Engineers must remain completely unattached to features built into the agent harness; scaffolding exists to mask temporary model limitations and should be deleted when the model natively outgrows it.
[04:48](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=288s) The Hyperbolic Time Chamber: AskUserQuestion and Artifacts
Operating at this frontier turns the Claude Code team into what they describe as a "hyperbolic time chamber" for the future of software engineering. Because model capability jumps require instant adaptation, a compact team frequently pivots between completely rewiring agent autonomy, rebuilding the security and permission architecture, and introducing new visualization systems. Staying effective requires software engineers to constantly recalibrate their internal mental model of what Claude can accomplish.
The rapid life cycle of the `AskUserQuestion` tool illustrates how swiftly user interaction paradigms become obsolete. Designed to make Claude collaborative and interactive rather than strictly executing plans in isolation, the tool proved extraordinarily difficult to balance during development—often taking weeks of prompt engineering and schema tuning just to get the model to call it appropriately. Yet almost immediately after the model mastered calling `AskUserQuestion`, the team found a superior pattern: having Claude spin up rich HTML artifacts featuring live diagrams and mockups to collect user input visually. Rather than getting stuck on any individual tool, the team builds composable primitives—ranging from permission boundaries to visualization canvases—that continuously re-layer as capabilities advance.
- **Agile architectural pivots:** Small teams simultaneously maintain core infrastructure (like permission systems) while spinning up brand-new proactive autonomous agents.
- **Tool evolution (`AskUserQuestion`):** Started as a post-planning checkpoint, evolved into a bespoke interactive tool call, and was subsequently supplanted by interactive HTML artifacts containing visual diagrams and mockups.
- **Primitive layering:** Systems are designed around composable primitives (visualization, permissions, context access) rather than static, monolithic agent behaviors.
[06:41](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=401s) Moving Off the Laptop: Hosted Containers, Loops, and Routines
The transition toward long-running loops began as a practical reaction to the physical limitations of local development. Running long agentic workflows on a local laptop created an immediate friction point: when leaving the office for the day, closing the machine killed the active agent. The alternative—walking through the parking lot holding an open laptop while running an agent—drew bewildered looks from colleagues. To decouple execution from physical machines, the team first migrated to remote hosted developer boxes over SSH, before ultimately creating Claude Code on the web backed by persistent hosted containers.
```mermaid
flowchart LR
accTitle: Evolution of Claude Execution Environments
accDescr: Evolution of agent execution from local laptop environments to cloud-hosted routines.
subgraph Local["Local Phase"]
L1["Laptop Terminal"] -->|"Closing lid halts execution"| L2["Awkward Parking Lot Commute"]
end
subgraph Remote["Cloud Evolution"]
R1["Hosted Dev Boxes (SSH)"] --> R2["Claude Code Web (Containers)"]
R2 --> R3["Autonomous Background Routines"]
end
Local --> Remote
```
While configuring remote container environments with appropriate repo and permission access required upfront work, it ended up driving a "10x productivity" jump. Once Claude was freed from the confines of an individual interactive session on a laptop, entirely new behavioral primitives emerged:
- **Continuous routines:** Claude instances can execute persistent background jobs, such as reviewing inbound user feedback every day, categorizing reports into importance buckets, and autonomously submitting fixes for high-confidence bugs.
- **Escaping session boundaries:** Breaking out of single-prompt interactive sessions enables engineering at a level of abstraction above the code, where developers orchestrate long-running loops that autonomously fix issues and execute workflows.
[08:52](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=532s) Rethinking Code Review in the Age of High-Volume Generation
As autonomous agents generate exponentially higher volumes of code across cloud routines and interactive sessions, standard human code review ceases to scale. If developers spend all their reclaimed programming time manually reading thousands of lines of machine-generated diffs, the productivity gains of agentic engineering collapse into a code review and security bottleneck. To combat this saturation, the team has turned toward automated code review bots and dynamic workflows to triage, inspect, and verify code at machine speed.
[09:09](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=549s) Rethinking Code Review: From Nitpicks to Architecture
Thariq opens up a discussion on how code review practices have fundamentally transformed within the team. Robert explains that Claude has changed where human reviewers spend their time and energy. In conventional code review, a reviewer often felt compelled to point out two or three minor stylistic nitpicks just as a proof-of-work mechanism—to signal, "I'm signaling to you that I read this code." With Claude capable of spotting and resolving those low-level details autonomously, the focus shifts entirely to architectural reasoning: evaluating API designs, understanding service boundaries, and ensuring broader contextual decisions align with internal team standards that the model might not have internalized when writing the pull request. Claude surfaces these high-level architectural questions directly to the human reviewer, lifting the abstraction layer above line-by-line pedantry.
```mermaid
flowchart TD
accTitle: Evolution of Code Review Focus
accDescr: Diagram contrasting traditional manual nitpicking with Claude-assisted high-level architectural review.
subgraph Old["Traditional Review"]
A["Manual Line-by-Line Review"] --> B["Catching Typos & Nitpicks"]
B --> C["Signaling Effort to Teammates"]
end
subgraph New["Claude-Assisted Review"]
D["Autonomous Bug & Nitpick Cleanup"] --> E["High-Level Abstraction Shift"]
E --> F["Human Focus: API & Service Boundaries"]
end
```
[10:42](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=642s) MapReduce Workflows and Test-Time Compute
Thariq recalls that the code review process was the first place the team explored massive fan-outs to discover potential bugs. This design pattern uses "test-time compute"—spending heavy inference time to put deep thought into complex problems. Sid explains how these dynamic workflows originated: Claude deploys a fan-out harness where dozens of sub-agents identify potential issues, followed by adversarial sub-agents that review each candidate bug from three distinct viewpoints to verify whether it is genuine.
This MapReduce-style orchestration filters out noise so that only critical issues reach human attention. Sid points out that the pattern applies far beyond code reviews—from locating performance bottlenecks to everyday deep research, like searching across hotels, Airbnbs, and destinations when planning a trip to Lake Tahoe with his parents. Claude autonomously writes deterministic orchestration code (such as `for` loops) to wire sub-agent pipelines together, ensuring consistency while maintaining agentic flexibility.
```mermaid
flowchart LR
accTitle: Fan-Out and Adversarial Review Architecture
accDescr: Pipeline showing fan-out across multiple sub-agents, adversarial verification, and aggregation.
subgraph FanOut["Fan-Out Stage"]
A["Task / Target PR"] --> B1["Worker Agent 1"]
A --> B2["Worker Agent 2"]
A --> B3["Worker Agent N"]
end
subgraph Reduce["MapReduce Aggregation"]
C1 --> D["Synthesized High-Signal Report"]
C2 --> D
C3 --> D
end
```
- **Test-Time Compute as Confidence:** Spending inference tokens on validation sub-agents reduces human cognitive load by filtering false positives.
- **Self-Generated Topologies:** Claude structures its own multi-agent graphs, deciding how outputs flow from one evaluation stage into the next.
- **Deterministic Glue:** Trust increases because deterministic code constructs (e.g., standard loops) orchestrate the agents, guaranteeing that items are not skipped during iteration.
[14:04](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=844s) Building Claude Tag with Claude Tag in Slack
Robert describes the team's dogfooding process: they use Claude Tag aggressively to build Claude Tag itself, ensuring its inner dev loop and local development environment are smooth enough for Claude to build and test end-to-end without human intervention. A major shift is the decoupling of the chat interface from the model's raw token stream. Instead of watching the internal monologue and low-level tool parameters scroll by, interactions happen via Slack messages that Claude explicitly sends.
While initially unsettling because developers could no longer see Claude's step-by-step thoughts in real time, the abstraction proved liberating. Allowing Claude room to "let Claude cook" highlighted how capable modern models are at executing multi-step development goals autonomously without tight oversight.
[16:13](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=973s) End-to-End Loops: Stakeholders, Funnel Optimization, and Verification
Thariq describes how Claude Tag clicked for him while building a new internal tool. Instead of manually writing specs and monitoring usage, he used Claude Tag entirely through Slack—even from his phone. Claude helped identify relevant internal stakeholders, created initial mockups, wrote the application code, added telemetry events, deployed the software, and continuously monitored incoming user feedback. When funnel conversion faltered, Thariq elevated his prompt from micro-managing features to setting an objective: asking Claude to analyze the event metrics and propose optimizations for the funnel.
Sid highlights that this process brings together the three core pillars of Claude Code: **verification**, **code review**, and **getting feedback**. When Claude creates a PR, it writes tests and captures UI screenshots to prove functionality. Thariq mentions that to verify behavior, he even had Claude record a video of itself interacting with the terminal user interface (TUI) before checking the branch out locally.
[18:25](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=1105s) The Evolution of Claude Code and Freeing the Developer's Mind
The team reflects on their changing habits when testing software, noting that while they still clone repositories and run code locally "just for sanity's sake" to try things out themselves, the trajectory is clear: developers will soon let Claude handle everything without ever needing to pull the code down. Looking back over the past year, Claude Code started as a core command-line utility and steadily layered on new primitives—such as auto mode, memory, and dynamic workflows. Initially, keeping track of all these rapidly moving pieces created significant cognitive overhead for engineers trying to parse everything happening beneath the surface.
```mermaid
flowchart TD
accTitle: Evolution of Developer Focus with AI Primitives
accDescr: Diagram illustrating the shift from manual low-level mastery to high-level system orchestration.
subgraph Past["Traditional Development"]
M1["Manual In-the-Weeds Coding"]
M2["Direct System Tuning & Syntax"]
M1 --> M2
end
subgraph Future["Modern Focus"]
F1["Freeing Cognitive Bandwidth"]
F2["Idea to Prototype to Production"]
F1 --> F2
end
Past --> Layer
Layer --> Future
```
The speakers acknowledge that the hardest part of being a software engineer today is freeing one's mind from low-level execution. Instead of asking how to tweak lines of code, engineers are forced to constantly reassess: *"What is possible now? How do we automate more?"* The primary discipline has shifted away from narrow implementation toward stepping back, expanding scope, and thinking bigger about entire architectures and product goals.
- **Layered primitives:** Claude Code expanded beyond a terminal harness by incorporating features like persistent memory, auto mode, and automated workflows.
- **Cognitive transition:** Modern engineering increasingly requires shedding micromanagement of code to focus on macro-level orchestration and automation possibilities.
---
[19:18](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=1158s) What Developers Miss: From In-the-Weeds Craft to Boundless Ideation
When asked what they miss most about pre-AI software engineering, the team points to the deep, meditative joy of low-level craft. One speaker recalls loving performance engineering—spending days profiling bottlenecks and intimately understanding machine performance. While Claude now outperforms human developers at optimizing code, the nature of their role has shifted: they still reap the rewards of fast systems, but attention has moved to shrinking the time it takes to go from raw idea to prototype and production. This requires trading deep, specialized mastery in a single technical silo for a high-level, zoomed-out creative view.
Another team member shares a fond nostalgia for obsessive visual UI polish, recounting spending an entire day hand-crafting stacked radial gradients in CSS just to achieve an exact replica of classic Mac OS X 10.4 Aqua interface buttons for a personal website. Knowing that Claude can generate that exact visual styling in seconds makes it impossible to justify spending hours on manual styling ever again. This shift evokes the feeling of being seven or eight years old, wanting to build a video game before knowing how to program and resorting to clickable buttons and hand-drawn shapes inside Microsoft PowerPoint. Today, Claude recreates that childlike feeling of unconstrained creation: lack of niche technical syntax is no longer a blocker to bringing complex software ideas to life.
Ultimately, the panel agrees that software engineering has always been the "profession of change." Decades ago, developers hand-wrote vanilla JavaScript without frameworks; industry shifts subsequently introduced modern component libraries, build tools, and compilers. AI-assisted development is simply the next acceleration of that cycle. While the specific daily tasks look radically different, the fundamental soul of engineering remains intact: using the newest tools available to solve complex problems and build great software.
- **Obsessive craftsmanship:** Nostalgia centers on lost manual joys, such as micro-optimizing execution speed or spending an entire day perfecting Mac OS X 10.4 Aqua bubble buttons using layered CSS gradients.
- **The PowerPoint analogy:** Early computing tools allowed kids to build interactive click-through games in presentation software without technical barriers; Claude restores that same immediate creative agency across the entire software spectrum.
- **The constant of engineering:** From hand-coding raw browser JavaScript to compiling frameworks to steering AI agents, the tools change but the core identity of the job remains creative problem-solving.
## Notable quotes
> [02:17](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=137s) Ride the Wave
> [04:48](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=288s) hyperbolic time chamber
> [14:04](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=844s) let Claude cook — Robert Boyce
> [18:25](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=1105s) just for sanity's sake
> [18:25](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=1105s) What is possible now? How do we automate more?
> [19:18](https://www.youtube.com/watch?v=S-sYlFiGFv8&t=1158s) profession of change
## Mentioned
Claude, Claude Code, Claude Tag, Thariq Shihipar, Sid Bidasaria, Robert Boyce, Slack, Sonnet 3.5, AskUserQuestion, ClaudeDevs, Mac OS X 10.4 Aqua, Microsoft PowerPoint, Airbnb, Lake Tahoe, YouTube, X
## Video description
A year ago, using Claude Code meant prompting, giving feedback, and accepting permission prompts. What does it look like now?
Thariq Shihipar, Sid Bidasaria, and Robert Boyce on the Claude Code team share how they use Claude Code in their day-to-day work, including why they do most of their coding through Claude Tag, why they give Claude goals rather than tasks, and why they delete harness features as the models outgrow them. They trace how the product expanded from the terminal into a multi-surface tool that incorporates primitives like auto mode, workflows, and routines. They also share what they miss most about their work as developers pre-Claude Code.
0:00 Intro
0:35 - Working through Claude Tag: from tool calls to goals
2:17 - Building on technology that evolves every two months
4:48 - How the Claude Code team uses Claude Code: AskUserQuestion, artifacts, and Claude Tag
6:41 - Running loops and routines remotely
8:52 - How code review inspired dynamic workflows
14:04 - Building Claude Tag with Claude Tag: verification and feedback loops in Slack
18:37 - What they miss about the old way of software engineering
Get started with Claude Code: https://code.claude.com/docs/en/overview
Follow ClaudeDevs on X for product updates and best practices from the Claude Code team: https://x.com/ClaudeDevs
Claude Code 团队如何使用 Claude Code
Claude Code 团队详细阐述了其内部开发流程如何从对单点代码生成进行微观管理，转变为通过 Slack 中的 Claude Tag 分配高层目标，目前这已占到其日常工程工作的约 70% 至 80%。由于底层前沿模型大约每两个月迭代一次，该团队坚持积极简化支撑框架的理念，一旦原生模型能力让诸如显式待办列表之类的脚手架过时，便会立即将其删除。开发工作已基本从本地笔记本电脑转移至云端容器，从而支持长时间运行的后台例程，以及利用对抗性子代理进行代码审查的 MapReduce 风格扇出工作流。工程师们最终解释了这种转变如何将人类的思维精力从逐行纠结语法的琐事中解放出来，将其职责提升至架构验证与高层产品设计层面。
Claude Code 团队目前有 70% 至 80% 的日常工程工作是通过 Slack 中的 Claude Tag 完成的，实现了从终端微提示到借助周围工作区上下文分配高层目标的转变。 (0:35)
底层基础模型的能力现在每两个月就会发生变化，迫使团队将代理脚手架（例如显式待办列表的运行支架）视为一次性补丁，一旦模型自身能力提升便予以删除。 (2:17)
将执行从本地笔记本电脑解耦并迁移至持久化云端容器带来了估计达 10 倍的生产力提升，释放了持续监控遥测数据并部署错误修复的持久自主例程的能力。 (6:41)
自动化代码审查通过 MapReduce 工作流采用了测试时计算，动态扇出的子代理和对抗性审查者对拉取请求进行预筛选，从而仅将高价值的架构问题呈报给人类。 (10:42)
Reading summary
Engineers on the Claude Code team report that rapid advancements in underlying foundation models have shifted their day-to-day workflow from manual, syntax-level coding toward asynchronous, high-level orchestration. They argue that building effective developer tools on models that change every few months requires treating harness code as disposable, delegating end-to-end execution to cloud-hosted agents, and refocusing human review on architectural judgment.
Asynchronous Slack Orchestration Over Terminal Micromanagement (0:00)
According to the team, roughly 70% to 80% of their daily software development now occurs asynchronously within Claude Tag in Slack, leaving terminal user interfaces and desktop workflows for the remaining 20% of tasks where developers want direct tactical control. Operating directly inside Slack provides the agent with ambient context, such as ongoing discussions, rationale behind architectural decisions, and organizational priorities, enabling more informed engineering decisions.
This integration marks a fundamental shift away from legacy workflows that relied on continuous conversational prompting, step-by-step tool inspections, and frequent permission approvals. Engineers now assign end-to-end objectives—spanning verification, code review, brainstorming, and monitoring—allowing the agent to plan and execute the necessary steps independently.
Disposable Scaffolding on Rapidly Shifting Models (2:17)
Because foundation model capabilities shift substantially every two months, the team approaches agent harness engineering as temporary scaffolding rather than permanent infrastructure. Scaffolding is built to mask transient model shortcomings and is discarded once the underlying model natively outgrows those limitations.
For example, during the Claude 3.5 Sonnet era, the team built an explicit to-do list harness to prevent the model from dropping tasks during long-horizon execution. Within a year, improvements in native model memory and state tracking rendered the feature redundant, leading to its removal. A similar pattern occurred with user interaction: a heavily tuned `AskUserQuestion` tool was rapidly phased out in favor of dynamic HTML artifacts that present interactive diagrams and visual mockups.
Decoupling Execution into Cloud-Hosted Routines (6:41)
The physical constraint of running long agent sessions on laptops—where closing the machine interrupted execution—prompted a migration first to remote SSH developer boxes and eventually to persistent, containerized web environments. The team attributes a reported tenfold productivity gain to this transition away from machine-bound sessions.
Decoupling agents from local hardware enabled autonomous background routines. Instances of Claude can run continuous jobs, such as reviewing inbound user feedback each day, triaging bug reports by severity, and autonomously preparing and testing pull requests for high-confidence bugs without active developer supervision.
Transforming Code Review with Test-Time Compute (10:42)
As automated generation created a surge in code volume, traditional line-by-line human review became unsustainable. Human reviewers have largely stopped focusing on minor syntax issues and stylistic nitpicks—tasks now handled autonomously—and instead dedicate review time to architectural alignment, service boundaries, and API design.
To manage code review at scale, the team adopted MapReduce-style workflows powered by test-time compute. Claude deploys fan-out harnesses of worker sub-agents to identify potential issues, tests each finding with adversarial verification agents evaluating from multiple perspectives, and uses deterministic orchestration code to aggregate high-confidence findings into a curated report for human developers.
Redefining Craft and High-Level Developer Focus (18:25)
With Claude handling tasks like generating telemetry, running automated tests, and recording terminal interaction videos for verification, the primary challenge for engineers has shifted from writing syntax to freeing cognitive bandwidth. Engineers must continuously re-evaluate what tasks can be automated rather than micromanaging low-level execution details.
Team members acknowledge nostalgia for the meditative craft of manual work, such as deep performance profiling or hand-crafting complex CSS gradients. However, they view AI development as the next stage in software engineering's long history of evolving abstractions, comparing modern tool use to early computing experiences where ideas could be quickly realized without niche technical syntax acting as an entry barrier.
The team concludes that the core identity of software engineering remains creative problem-solving, even as daily routines shift toward managing autonomous agents. However, they note that the transition remains incomplete, as engineers still periodically clone code locally to verify behavior manually while the toolchain matures toward full autonomous reliability.
Source quotes
[2:17] Ride the Wave
[4:48] hyperbolic time chamber
[6:41] 10x productivity
[9:09] Robert Boyce: I'm signaling to you that I read this code.
[10:42] Thariq Shihipar: test-time compute
[14:04] Robert Boyce: let Claude cook
[18:25] just for sanity's sake
[18:25] What is possible now? How do we automate more?
[19:18] profession of change
Original transcript
[0:00] Do you guys have any thoughts
[0:01] about your next year?
[0:02] I feel like it's hard for me
[0:03] to think about the
next two months.
[0:06] Let alone the next year.
[0:20] I don't know
if you guys know it.
[0:21] It's been almost a year
since I joined
[0:23] Claude Code.
[0:24] It’s crazy to think about
how far we’ve come
[0:26] from a year ago
when we were like
[0:28] prompting Claude Code,
giving it feedback,
[0:30] accepting permission
prompts, to now.
[0:32] So, like,
[0:32] tell me about how you work
with Claude Code right now?
[0:35] Yeah.
[0:35] Now I'm doing so
much of my work
[0:37] Through Claude Tag,
actually.
[0:39] And the kinds of problems
that I'm giving to
[0:42] Claude Tag are just worlds
more complicated
[0:45] and challenging than,
you know, implement this class
[0:49] or write this function,
[0:51] which is kind of where
things started at
[0:53] with Claude Code.
[0:54] I think that's
really complementary
[0:55] to the sort of the shape
of like Claude
[0:57] Tag living in Slack
as like a Slack native agent,
[1:00] because it means they can go
and look up
[1:03] all this additional context
around like,
[1:05] hey, what's the product
context?
[1:06] Like, what are the decisions
that we as a team
[1:08] have made about
what this product should be?
[1:10] And that just makes its
decision making a lot better.
[1:14] Having access to all that
information and understanding
[1:17] how to incorporate that
into the choices
[1:20] that the agent is making.
[1:21] Yeah.
[1:22] My work feels pretty similar too.
[1:23] I think, 70 to 80% of my work
happens on Claude Tag now,
[1:26] and for 20% of the work,
I will maybe
[1:28] open up the TUI
[1:29] or the desktop app to like,
refine something.
[1:31] Or if I want to be
micromanaging
[1:33] my Claudes,
I will do that.
[1:35] I think we've gone from just,
[1:37] you know,
caring about the transcripts
[1:39] so much and like,
caring about each individual
[1:41] tool call
[1:42] and each individual decision
that the model makes
[1:45] to just a zoomed out
view of, like,
[1:47] I have a goal and
I'd like to achieve this goal.
[1:50] And you just kind of give
that goal to the model
[1:53] to achieve for you.
[1:54] You know,
what I've been reflecting on
[1:55] is just how much.
[1:56] the software development,
life cycle has changed
[1:59] and how we've sort of like,
[2:00] learned all these lessons
along the way,
[2:03] you know, like building
Claude Code, building
[2:05] all these primitives
that tie together.
[2:08] Eventually into Claude Tag,
which is like,
[2:10] how we're doing everything
from like verification to code
[2:13] review, like brainstorming,
monitoring.
[2:17] Tell me about how working on
Claude Code
[2:18] compares to working on,
previous software products?
[2:22] I mean, there's always
a shelf life on any product,
[2:25] or the technology underneath
the products rather.
[2:27] I think the shelf life for
the technology
[2:29] used to be
in the order of years.
[2:31] So it used to be like,
[2:32] I'm going to make this product
[2:33] and I have high confidence
that this is going to
[2:36] be a thing for,
you know, a few years or more.
[2:39] With models and AI models,
it's like the technology
[2:42] fundamentally
shifts underneath you
[2:43] every two months
and it's like,
[2:45] maybe it's
getting compressed
[2:47] as time moves forward too.
[2:48] And so it's kind of hard
because you have to stay
[2:52] at the frontier
and you have to kind of
[2:54] go past the frontier really
to like, feel that edge.
[2:58] But at the same time,
you have to provide value
[3:00] to people
using the models today.
[3:02] And in the now.
[3:04] And so it's
this like balancing act,
[3:06] which is part art, part
science stuff, like how do I,
[3:09] how do I build
for this technology
[3:11] that's moving
so fast underneath me?
[3:14] Is there like, a moment
where you felt like
[3:16] you just caught
the wave in the right part?
[3:19] I think the first time
I felt,
[3:21] the “ride the wave”
feeling was maybe to do lists.
[3:24] Oh, okay. Yeah.
[3:25] Like, that was, this was like,
maybe Sonnet 3.5.
[3:28] And the models just
[3:29] were not able to do
any kind of long horizon work.
[3:32] And you would give it
like five things to do,
[3:34] and it would do three things
and just give up.
[3:37] And so that's
when we were like, oh,
[3:38] maybe you give it a to do list
and it'll do really well.
[3:41] And it did really well.
[3:42] It was just like,
whoa, this is
[3:44] exactly the thing we need
for this moment in time.
[3:46] But you know, a year from then,
like, it's disappeared,
[3:49] like you don't really need the
to do list anymore.
[3:51] Like, there's, like,
[3:52] you know, more complex
memory states
[3:54] and things
that you can rely on.
[3:56] And I think this is
[3:56] the perfect
example of how,
[3:58] you got to be very
unattached
[4:00] to the things
you're building.
[4:01] Because they're going
to go away fairly quickly.
[4:04] I think that it's like,
the fact that
[4:08] we build these things
into the Claude Code harness,
[4:11] and a lot of that
[4:12] is just to cover
for some of the failure modes
[4:16] that the current state
of the model has.
[4:19] And as the models get better,
[4:22] we have the freedom now
to say like, oh, actually
[4:24] all these like features
that we built, like
[4:26] it's not relevant anymore.
We don't need those.
[4:27] We can get rid of them.
[4:29] And the thing that
[4:31] balances that out
is, okay,
[4:32] well now we're doing
even bigger, more challenging
[4:35] tasks in Claude Code.
[4:36] And what are the tools
that the model
[4:38] needs to be able
to stay coherent
[4:40] and do a good job on those
even bigger tasks.
[4:43] And the tools
that we need to give it
[4:45] start to look different
[4:46] as the scope of the
task changes.
[4:48] A lot of people ask me,
[4:49] how does the
Claude Code team work?
[4:51] And I think one thing
that's unique
[4:53] about the Claude
Code team is like,
[4:55] we have to keep up with
the models really closely.
[4:57] So we need to, like,
[4:58] you know,
sometimes make big changes
[5:00] very quickly where we're like,
oh, the model is so good,
[5:02] now we need to make
[5:03] a whole new proactive agent,
and it needs to be like
[5:06] a small team
that does it while it's also,
[5:08] while we're also like,
[5:09] rewriting the permission
system
[5:11] and creating artifacts
and things.
[5:12] So I think in some ways
we're this
[5:14] like hyperbolic time
chamber of like,
[5:17] where software
development is going.
[5:18] I don't think most products
[5:19] hav as short a shelf life.
[5:22] You know, and have to keep up
on the edge much.
[5:24] But definitely
as an engineer,
[5:26] you kind of have to do
some of this, right?
[5:28] You have to sort of like,
[5:29] you know, understand where
the capabilities are going.
[5:31] And obviously
we try and help with that
[5:33] as much as possible
through the product.
[5:35] But, yeah, it's
also good to like keep
[5:37] like your mental model
of Claude as well.
[5:39] I mean, I think when you added
the ask user question tool,
[5:42] that was another kind
of example of
[5:44] like riding through the wave,
[5:46] what were you thinking
[5:47] when you created
that tool and
[5:49] what was going on
through your head?
[5:50] I wanted Claude to be interactive.
[5:52] And initially I had it
after planning basically.
[5:56] And then I was like,
oh, wait, what
[5:57] if it's just a tool
that it can call?
[5:59] And it took me so long
to design the tool.
[6:01] Like it was really hard to get
Claude to call the tool well,
[6:06] and then eventually, I designed it.
[6:08] And then it just started
[6:09] getting really good
at calling the tool.
[6:10] And then recently
I'm just like,
[6:13] I don’t even use the tool as much.
[6:14] I just create an artifact.
[6:15] And the artifact
[6:16] asks me questions,
you know,
[6:18] and it's like in HTML,
[6:19] it has diagrams and mockups
and things like that.
[6:22] I'm like, it happened
so quickly, right?
[6:24] Where it was like,
[6:25] the tool could barely do it
and now it can.
[6:27] But yeah, I think this
happens a lot in Claude Code.
[6:29] I think that
[6:30] the way I think we go
about is like,
[6:32] we create these primitives
[6:34] where it's like, okay,
[6:35] how do permissions work?
[6:37] How do visualizations work?
[6:39] All of these things.
[6:40] And then they sort of
layer together.
[6:41] Tell me about loops, like,
how do you use them?
[6:44] I mean,
[6:44] I think it's interesting
[6:45] to track the journey of
[6:46] how we arrived at loops
in some ways. Right?
[6:48] It's like, we like,
I used to run everything
[6:51] locally on my laptop,
[6:52] and at some point I had
to go back home,
[6:55] you know, from the office.
[6:57] And so I would have
to shut down my laptop
[6:59] and I'd be like,
that sucks.
[7:00] Like, my agent’s not
running anymore.
[7:02] You didn’t leave it open?
[7:04] Yeah, you could do that
but then I’d have to go
[7:06] to the parking lot and like,
people would look at me funny.
[7:08] Yeah, yeah.
[7:10] But what
I started doing then,
[7:12] was I started using like,
[7:13] our remote hosted
developer boxes.
[7:16] Yeah.
[7:16] And so, like,
those were my way of,
[7:19] okay, I don't need my laptop
on at all times.
[7:21] It's just,
[7:22] it's running and it's running
[7:23] in a hosted environment,
so I can just do my thing.
[7:25] Yeah.
[7:25] But that's also unsatisfying
in some ways,
[7:28] because then, like,
you got to, like,
[7:29] you know,
ssh into your environments
[7:31] and kind of get back
to your hosted surface.
[7:35] And so that's when,
I guess,
[7:38] Claude Code on the web
was created. Right?
[7:39] So it's like hosted containers
that you have,
[7:42] that can just keep running
in the background.
[7:44] But even then, like it was,
[7:47] it was a little tricky
to get started
[7:49] because if you want to use
a container to host your,
[7:52] host your dev environment,
[7:53] you need to give it access
to your dev environment.
[7:56] And setting that up
is a bit of a pain.
[7:58] Yeah. It's totally worth it,
in my opinion.
[8:00] I think it's like, you know,
[8:01] 10x my productivity
ever since we did that.
[8:03] But that was kind
of the challenge there.
[8:05] And so I think
[8:06] that's the origin story
of like how
[8:08] we kind of came across this,
[8:10] Claude running locally,
to Claude needs to run on the cloud.
[8:12] And now if it’s
running on the cloud,
[8:14] you can do
really interesting things,
[8:15] like you can have routines
and you can be like,
[8:18] you know, every day go and
look at all the feedback
[8:22] that we're getting
[8:23] and look at, you
know, bucket them into
[8:26] buckets of importance
[8:27] and fix the ones that
it actually has
[8:30] high confidence in fixing.
[8:31] This is the whole like,
loop journey
[8:33] that Boris talks
about a lot too.
[8:34] It's like, you go from,
you know, prompting a model
[8:38] in a session,
and you do,
[8:41] like breaking that
boundary of like a session
[8:43] and instead
[8:44] prompting something
that's one level above that.
[8:47] Yeah.
[8:48] That's then going and fixing
[8:50] bugs or, like,
doing your bidding for you.
[8:52] Yeah.
[8:52] I actually wanted to talk
more about code review
[8:55] you know, and security,
[8:56] because I think
this is one of those things
[8:57] where, okay, you're
writing a lot more code.
[8:59] More code
is being generated, and
[9:02] you don't want your job to be,
like, reviewing code, right?
[9:05] So, yeah,
obviously we have like,
[9:07] our code review bot right now.
[9:09] But generally I
wanted to ask you guys
[9:10] about like how, you know,
code review has changed
[9:12] inside of the team and like,
how we do it right now?
[9:16] I think one big thing actually
has been, Claude
[9:20] really helps human reviewers
[9:22] choose where to focus
their time and energy.
[9:25] I think like a common thing
that I saw happen
[9:29] in traditional human
code review is
[9:33] you would have someone go
and review the code
[9:35] and they would like,
pick out, like,
[9:37] you know, three
little nit picks to post.
[9:39] And it was kind of just like,
[9:40] I'm signaling to you
that I read this code.
[9:44] It’s like, here's
my like three little things
[9:45] that I want to point out
to prove that I actually
[9:47] was like reading
through this carefully.
[9:49] Now you can have Claude
figure out those little things
[9:53] and address them autonomously.
[9:54] So I was like,
that's not really
[9:55] the important part
of human code review anymore.
[9:58] Yeah.
[9:58] What is important
[10:00] is understanding
maybe the bigger picture.
[10:02] It's like,
[10:02] maybe Claude doesn't
have a full understanding of
[10:05] why is this API structured
the way it is?
[10:08] Or, you know,
[10:08] the service boundaries
are drawn in a particular spot
[10:11] for a reason
that maybe Claude,
[10:13] hasn't fully internalized
when I was writing the PR.
[10:17] So being able to pull
[10:18] information
like that into code review,
[10:22] and then hand that
information off to a human,
[10:25] I think is a really valuable thing
that Claude can do
[10:29] that keeps you from getting
pulled into that little, like,
[10:32] oh, I'm just going to, like,
[10:34] nit pick something
because I'm, like,
[10:35] reading through the code
line by line and,
[10:38] just level up the
[10:40] abstractions
that you're thinking
[10:41] about as a human code
reviewer.
[10:42] I think code
review was the first time
[10:44] where we did
this big fan out
[10:46] where we're like,
okay, like,
[10:47] how do you find,
you know, every bug, right?
[10:50] Or how do you like search
across potential bugs?
[10:53] And we do this big fan out
and then,
[10:55] you know, coalesce it,
which is like,
[10:57] you know, what we call
test time compute, right?
[10:58] Like how we use
a lot of inference time
[11:02] to put a lot of thought
and compute into a problem.
[11:06] And this led to workflows,
right?
[11:08] So could you tell me
about that Sid,
[11:10] and how you built workflows?
[11:11] Code review was a big part of
how workflows came about
[11:16] in the first place.
[11:16] Yeah.
[11:17] Like we
[11:18] we have this,
as you were saying,
[11:19] like massive, fan out thing
where it was
[11:22] kind of like a,
[11:23] almost like, a custom harness
[11:25] where you tell Claude to go out
and fan out and find bugs.
[11:28] And then for each bug,
you might
[11:30] do an adversarial review
where you ask it to
[11:32] look at the bug
from three different,
[11:35] you know,
[11:35] opinions or
perspectives and
[11:38] see if the bug is
actually real.
[11:39] What that does is like it
filters out
[11:41] all these bugs for you
and gives
[11:42] you just
the most important ones
[11:44] that require
or need your attention.
[11:48] And it's not just code review.
[11:49] Like you could do
the same thing for many,
[11:51] many different types
or classes of problems.
[11:53] Yeah.
[11:54] You could do the same thing
[11:55] for performance bugs
or performance issues.
[11:58] You could do the same thing
[11:59] for just general purpose
deep research. Right?
[12:01] Like I want to figure out,
like, you know,
[12:03] I'm taking my parents to Tahoe
[12:04] next week and, like, okay,
where do I, where do I stay?
[12:08] And you could do, like,
a fan out there and
[12:10] that's helpful too.
[12:11] Claude is actually really good
at making its own harnesses.
[12:14] Yeah.
[12:14] Like Claude
[12:15] can figure out
[12:16] what this fan out
should look like,
[12:18] what the topology
should look like,
[12:20] how it should kind of wire
in the output of one agent
[12:23] into the next level,
and then, like,
[12:25] finally summarize it
and give it back to me.
[12:28] And so that was kind of
the origin story of that as.
[12:30] And an example is,
[12:31] okay, you're planning a trip.
[12:32] So you have it like
[12:34] do like ten different search
requests across like Tahoe,
[12:37] like bathhouse Tahoe, Hotel
Tahoe, Airbnb or something.
[12:41] Right?
Places to go.
[12:43] Yeah.
[12:43] It gives you
a bunch of results.
[12:45] And then you have
some agents
[12:46] that sort them or
[12:48] figure out the most
interesting results
[12:51] and then maybe
some agents who
[12:52] verify them.
Is that right?
[12:54] And then it gives you
an end result.
[12:55] Exactly.
[12:56] Like the problem
is really it's,
[12:58] it's like you're fanning out
and once you fan out,
[13:01] you just have so much
information,
[13:03] that you need to
then filter back.
[13:05] It's like a MapReduce problem.
[13:06] Yeah.
[13:07] And you need
[13:07] to filter back
for human consumption,
[13:09] because if I read the fan out
output I'm going to go crazy.
[13:12] Right?
[13:13] So you need something to help
build confidence
[13:16] and the way to build
confidence in this case
[13:19] is just to throw test time
compute at the problem.
[13:22] And so you kind of build
more confidence that way.
[13:25] I think the other thing
[13:25] that's really interesting
about workflows is because
[13:28] the agent is writing code to
orchestrate the sub agents,
[13:33] it's this cool mix of
[13:35] deterministic code
defined behavior,
[13:38] as well as the, you know,
agentic LLM behavior.
[13:42] And I think that that helps
give me confidence
[13:45] when like Claude writes
[13:46] a workflow to iterate,
you know, it's like,
[13:48] here's a for loop that's going
to run over these items.
[13:50] I'm like,
oh yeah, the for loop, it's
[13:52] not going to skip
one of the items like it's
[13:54] going to apply
the same technique
[13:56] to all of these things
equally.
[13:58] I find that that's really,
that really improves my,
[14:01] my trust.
[14:01] Like, oh,
I know that Claude is doing
[14:03] what I want it to do here.
[14:04] Want to talk about
Claude Tag.
[14:06] Like, I know Robert, you're
[14:07] building Claude Tag right now.
[14:09] But. Yeah.
[14:09] How are you using it? Like,
Tell us about it.
[14:11] Yeah, yeah, I think,
[14:12] so I mentioned earlier,
but we're using Claude
[14:15] Tag to build Claude
Tag really aggressively.
[14:17] Yeah.
[14:18] And that's actually been
a lot of
[14:19] my focus is making sure
[14:20] that, like, Claude Tag
is unblocked
[14:22] on being able to develop
Claude Tag itself.
[14:24] Making sure that
the development environment
[14:27] and dev loop are really,
really easy for Claude to use.
[14:32] It can just, like,
do everything that
[14:33] I, as a human need to do
to build the software and test
[14:37] that it's working end to end.
[14:38] As we build more and more,
complex, heavily
[14:42] integrated pieces of software,
that job gets harder, right?
[14:45] So that making sure that
Claude is able to do that
[14:48] sort of thing has been
a big focus for me.
[14:51] This is the first time
we've had the user interface
[14:56] more fully decoupled
from the transcripts.
[15:00] Okay.
[15:00] So it's like,
we're actually like,
[15:01] we are working now at a level,
[15:03] one level of abstraction away
from, like the actual tokens
[15:06] that are being output
from Claude.
[15:08] So when you see a message
from Claude Tag in Slack,
[15:11] it's calling a tool
to send that message to you.
[15:14] Yeah.
[15:14] But its internal monologue
essentially
[15:16] is not visible to you
in Slack.
[15:18] Like there is a link to view
the full transcripts
[15:20] from Claude,
[15:21] but the primary user interface
is through a messaging tool.
[15:27] And that abstraction
was, like, a little scary
[15:30] to get through at first.
[15:30] We're like, oh, like,
I can't see everything
[15:32] that Claude is thinking
as it's like thinking it.
[15:34] Yeah.
[15:34] But it's also been,
[15:36] I think, really freeing in
terms of just like, oh,
[15:40] Claude is choosing
what to say to me and when.
[15:43] And I'm not thinking
about the details of like,
[15:46] which tools is it calling,
what parameters is it
[15:48] sending to the tools
as it's using them?
[15:50] And like being forced
even to let Claude cook.
[15:56] And seeing that the models
now are good enough.
[16:00] Yeah.
[16:01] That I'm getting back
good results without needing
[16:04] to supervise the transcripts
in detail.
[16:07] Right.
[16:07] Is like, it has been a forcing
function of like,
[16:10] Oh, yeah,
[16:10] these models are actually
getting really good now.
[16:13] Claude Tag
really clicked
[16:13] for me
recently
[16:14] because I've been
developing
[16:15] a new tool.
[16:16] I actually need
a lot of buy in from people.
[16:17] So the first thing I tried
was like,
[16:19] hey, like, I'm
thinking of this idea,
[16:21] who should I talk to
[16:22] who might be interested
in it? Right?
[16:27] And then so
I get these stakeholders
[16:29] and then I do some mock ups
and it's all in Slack.
[16:31] So I can, like,
view it on my phone even,
[16:33] it makes mocks
up for me.
[16:35] It does the implementation,
you know, and then,
[16:38] but the implementation
is like, you know,
[16:40] I don't know if this
[16:41] tool really works or not.
[16:42] So I add a lot of like
events to it. Right?
[16:45] And then I,
you know, deploy it internally
[16:47] and see like kind of how
people are using it.
[16:49] Then Claude Tag
is like monitoring it for me.
[16:51] And I'm like,
oh, hey, like,
[16:53] how are people using it?
[16:54] Is anyone giving me feedback?
[16:55] And then I can just like
[16:56] drop in instantly
and be like, yes.
[16:57] Like, you know, like
Claude tags me
[16:59] when someone else
gives me feedback about it.
[17:01] And so I can be like
more responsive,
[17:03] I can have a higher
confidence that it works.
[17:04] Right.
[17:05] And then sometimes
I was looking at the events
[17:07] and I wanted to improve
some of the funnel.
[17:08] Like I felt like users
weren't going all the way.
[17:11] And initially I was like,
I have an idea.
[17:13] I'm going to like,
ask it to do this idea.
[17:15] But then I was like, wait,
[17:16] let me ask Claude
to improve the funnel.
[17:18] You know,
[17:18] like come up
with some ideas here.
[17:20] And maybe I can give my idea
as an example,
[17:22] but I want to sort of,
[17:23] like, work with it at that
higher level,
[17:25] and that, like, really
clicked for me.
[17:26] I think you're touching on
some great points here, right?
[17:28] Because effectively
there's verification,
[17:32] there's code
review,
[17:34] and there's getting feedback.
[17:37] So it's like connecting
[17:38] to your data store
or your event store
[17:40] where you get feedback in
some ways, like maybe metrics
[17:43] or maybe it's a Slack,
maybe it's a GitHub issues,
[17:45] whatever else it is.
[17:46] And all three of these
are primitives in Claude Code.
[17:49] Yes.
[17:49] Like verification
is so important
[17:51] because like I think we,
[17:52] for our team especially,
we have, you know,
[17:55] really paid a lot of attention
to verification.
[17:58] And so when Claude creates
a PR for me for Claude Code.
[18:01] It tests it, it sends me screenshots
[18:05] from what it would look like.
[18:07] And then
you kind of get confidence.
[18:09] So in your case too,
like when you were,
[18:11] you know, asking you
to verify, like you didn't,
[18:13] did you have to open up,
[18:15] did you open up the TUI?
[18:17] Only to like,
[18:18] so first
I asked if to record itself
[18:20] using the TUI, you know,
and then after I did that,
[18:23] I was like,
I’ll like clone it myself.
[18:25] And then try it out.
[18:26] Just for sanity’s sake
[18:27] I wanted to make sure that I
at least check.
[18:29] Yeah, just to like,
you know, use it myself.
[18:32] I feel like eventually,
you know,
[18:33] I’ll just let Claude,
not even clone it.
[18:36] I think looking back
at the evolution over the past
[18:39] over the part year,
to me it’s
[18:40] sort of like
[18:40] we started with
Claude Code and then we
[18:43] started adding
these primitives
[18:45] that would work
[18:45] like auto mode and memory
and workflows.
[18:48] There was a lot to keep track
of as a developer, right?
[18:51] To just be like, oh,
[18:52] what's all this stuff
happening?
[18:54] But you kind of
have to do that.
[18:56] I do think that's like
[18:57] the hard part about
[18:59] being a software engineer
these days is like,
[19:00] it's like
[19:01] freeing your mind
[19:02] kind of like,
[19:03] there's so much.
I think you always
[19:05] had to do is,
you always have to be like,
[19:07] okay, what is possible now?
How do we like, automate more?
[19:09] But I think, like,
how do we, you know,
[19:13] step back and think
bigger, right?
[19:15] I think is a really
important part,
[19:18] but I am curious
if there's, like, anything
[19:20] you guys miss about
[19:22] the old part of software
engineering?
[19:24] And how things used to work.
[19:26] For me, I used to get a lot of joy
[19:27] from performance engineering.
[19:30] And so that means, like,
[19:31] really digging into a system
[19:33] and increasing
its performance.
[19:34] I think Claude is much better
at that than I am now.
[19:38] But I still get to reap
the benefits
[19:40] of the actual performance
improvements, which is nice.
[19:43] The other thing that I think
I've been focusing a lot on
[19:45] is just creating
new ideas quicker.
[19:48] So if I have an idea,
going from idea
[19:50] to prototype to production
is much faster.
[19:52] Yeah.
[19:52] And so I think more of
my attention is now going
[19:54] on, like new ideas
[19:56] and how quickly
I can bring them to life.
[19:58] And so it's like
[19:58] I've had to shift
my kind of like paradigm from,
[20:02] you know, getting really deep
into the weeds to like,
[20:05] more zoomed out
over time.
[20:06] Yeah. Yeah.
[20:06] Like less mastery
in that specific thing,
[20:09] of performance that you’re
spending a ton of time on.
[20:11] Exactly.
[20:12] I think kind of
a similar thing for me.
[20:14] I'm a very, like detail
oriented.
[20:19] I love to get into the
weeds of UI design
[20:23] for my personal website,
like, I made this,
[20:26] like super detailed
CSS recreation of the Mac
[20:30] OS 10.4 aqua like buttons.
[20:33] And I probably spent
like a day
[20:35] like getting the exact layer
of, like, radial gradients,
[20:39] like stacked up to make
this perfect recreation of it.
[20:41] And like,
[20:42] that's the type of thing
where I'm like,
[20:43] oh, Claude
can just do that for me now.
[20:46] And like, I wouldn't ever go
and do that manually now.
[20:49] It kind of brought me
[20:50] back to thinking about
when I was probably 7 or 8.
[20:54] I really wanted to make
a video game.
[20:55] Yeah.
[20:56] And, like,
I didn't know how to code yet,
[20:58] but I was just like,
you know what?
[20:59] I have, like, PowerPoint
[21:02] and I can use, like,
PowerPoint to like,
[21:04] make, like,
[21:04] clickable things and like,
draw these shapes and stuff.
[21:07] Yeah.
[21:07] It was like
[21:08] that was a tool that
I was able to use at that age.
[21:11] Thinking now
about how Claude kind of makes
[21:15] the entirety of software
engineering accessible to me,
[21:19] it's like whatever
idea I have
[21:21] I can,
I don't have to be like, oh,
[21:23] I don't have the technical
skills.
[21:25] Like I'm not able
to solve this problem.
[21:28] Like, I can say, here's
what I want to accomplish.
[21:30] Let's like break it
down and figure out
[21:32] how to work with Claude
to make it happen.
[21:35] Yeah.
[21:36] Just everything
kind of inside of that,
[21:38] realm of software
engineering feels like
[21:41] it's within my grasp now,
which is really exciting.
[21:44] I feel like software
engineering
[21:45] is like the profession
of change.
[21:47] You know, like,
[21:48] I think you look back
like 10 or 20 years
[21:50] and you're like,
oh, like, you know.
[21:52] You're like handwriting
JavaScript without like,
[21:54] any sort of frameworks.
[21:56] And then you invent
frameworks and,
[21:57] you know, compilers
and all of these things.
[21:59] And, it's happening faster
now, but it's still like
[22:03] fundamentally
software is about
[22:05] how do you use these things
to create something
[22:07] incredible and
make more
[22:09] and more great software,
right?
[22:11] It's like problem solving.
[22:12] Like you say.
[22:13] Exactly.
[22:13] You're solving
different problems,
[22:14] but you're still problem
solving.
[22:16] Totally.
