{"id":35584,"date":"2025-07-25T05:41:12","date_gmt":"2025-07-25T05:41:12","guid":{"rendered":"https:\/\/www.newsbeep.com\/us\/35584\/"},"modified":"2025-07-25T05:41:12","modified_gmt":"2025-07-25T05:41:12","slug":"how-anthropic-teams-use-claude-code-anthropic","status":"publish","type":"post","link":"https:\/\/www.newsbeep.com\/us\/35584\/","title":{"rendered":"How Anthropic teams use Claude Code \\ Anthropic"},"content":{"rendered":"

Anthropic’s internal teams are transforming their workflows with Claude Code<\/a>, enabling developers and non-technical staff to tackle complex projects, automate tasks, and bridge skill gaps that previously limited their productivity.<\/p>\n

To learn more, we spoke with the following teams:<\/p>\n

Data infrastructureProduct developmentSecurity engineeringInferenceData science and visualizationProduct engineeringGrowth marketingProduct designReinforcement learning (RL) engineeringLegal<\/p>\n

Through these interviews, we’ve gathered insights on how different departments use Claude Code, its impact on their work, and tips for other organizations considering adoption.<\/p>\n

Claude Code for data infrastructure<\/p>\n

The Data Infrastructure team organizes all business data for teams across the company. They use Claude Code for automating routine data engineering tasks, troubleshooting complex infrastructure issues, and creating documented workflows for technical and non-technical team members to access and manipulate data independently.<\/p>\n

Main Claude Code use cases<\/p>\n

Kubernetes debugging with screenshots<\/p>\n

When Kubernetes clusters went down and weren’t scheduling new pods, the team used Claude Code to diagnose the issue. They fed screenshots of dashboards into Claude Code, which guided them through Google Cloud’s UI menu by menu until they found a warning indicating pod IP address exhaustion. Claude Code then provided the exact commands to create a new IP pool and add it to the cluster, bypassing the need to involve networking specialists.<\/p>\n

Plain text workflows for finance team<\/p>\n

Engineers showed Finance team members how to write plain text files describing their data workflows, then load them into Claude Code to get fully automated execution. Employees with no coding experience could describe steps like “query this dashboard, get information, run these queries, produce Excel output,” and Claude Code would execute the entire workflow, including asking for required inputs like dates.<\/p>\n

Codebase navigation for new hires<\/p>\n

When new data scientists join the team, they’re directed to use Claude Code to navigate their massive codebase. Claude Code reads their Claude.md files (documentation), identifies relevant files for specific tasks, explains data pipeline dependencies, and helps newcomers understand which upstream sources feed into dashboards. This replaces traditional data catalogs and discoverability tools.<\/p>\n

End-of-session documentation updates<\/p>\n

The team asks Claude Code to summarize completed work sessions and suggest improvements at the end of each task. This creates a continuous improvement loop where Claude Code helps refine the Claude.md documentation and workflow instructions based on actual usage, making subsequent iterations more effective.<\/p>\n

Parallel task management across multiple instances<\/p>\n

When working on long-running data tasks, the team opens multiple instances of Claude Code in different repositories for different projects. Each instance maintains full context, so when they switch back after hours or days, Claude Code remembers exactly what they were doing and where they left off, enabling true parallel workflow management without context loss.<\/p>\n

Team impact<\/p>\n

Resolved infrastructure problems without specialized expertise<\/p>\n

Resolves Kubernetes cluster issues that would normally require pulling in systems or networking team members, using Claude Code to diagnose problems and provide exact fixes.<\/p>\n

Accelerated onboarding<\/p>\n

New data analysts and team members can quickly understand complex systems and contribute meaningfully without extensive guidance.<\/p>\n

Enhanced support workflow<\/p>\n

Claude Code can process much larger data volumes and identify anomalies (like monitoring 200 dashboards) that would be impossible for humans to review manually.<\/p>\n

Enabled cross-team self-service<\/p>\n

Finance teams with no coding experience can now execute complex data workflows independently.<\/p>\n

Top tips from the Data Infrastructure team<\/p>\n

Write detailed Claude.md files<\/p>\n

According to the team the better you document your workflows, tools, and expectations in Claude.md files, the better Claude Code performs. This makes Claude Code excel at routine tasks like setting up new data pipelines when you have existing design patterns.<\/p>\n

Use MCP servers instead of CLI for sensitive data<\/p>\n

They recommend using MCP servers rather than the BigQuery CLI to maintain better security control over what Claude Code can access, especially for handling sensitive data that requires logging or has potential privacy concerns.<\/p>\n

Share team usage sessions<\/p>\n

The team held sessions where members demonstrated their Claude Code workflows to each other. This helped spread best practices and showed different ways to use the tool they might not have discovered on their own.<\/p>\n

Claude Code for product development<\/p>\n

The Claude Code Product Development team uses their own product to build updates to Claude Code, expanding the product’s enterprise capabilities and agentic loop functionalities.<\/p>\n

Main Claude Code use cases<\/p>\n

Fast prototyping with auto-accept mode<\/p>\n

Engineers use Claude Code for rapid prototyping by enabling “auto-accept mode” (shift+tab) and setting up autonomous loops in which Claude writes code, runs tests, and iterates continuously. They give Claude abstract problems they’re unfamiliar with, let it work autonomously, then review the 80% complete solution before taking over for final refinements. The team suggests starting from a clean git state and committing checkpoints regularly so they can easily revert any incorrect changes if Claude goes off track.<\/p>\n

Synchronous coding for core features<\/p>\n

For more critical features touching the application’s business logic, the team works synchronously with Claude Code, giving detailed prompts with specific implementation instructions. They monitor the process in real-time to ensure code quality, style guide compliance, and proper architecture while letting Claude handle the repetitive coding work.<\/p>\n

Building Vim mode<\/p>\n

One of their most successful async projects was implementing Vim key bindings for Claude Code. They asked Claude to build the entire feature, and roughly 70% of the final implementation came from Claude’s autonomous work, requiring only a few iterations to complete.<\/p>\n

Test generation and bug fixes<\/p>\n

The team uses Claude Code to write comprehensive tests after implementing features and handle simple bug fixes identified in pull request reviews. They also use GitHub Actions to have Claude automatically address Pull Request comments like formatting issues or function renaming.<\/p>\n

Codebase exploration<\/p>\n

When working with unfamiliar codebases (like the monorepo or API side), the team uses Claude Code to quickly understand how systems work. Instead of waiting for Slack responses, they ask Claude directly for explanations and code references, saving significant time in context switching.<\/p>\n

Team impact<\/p>\n

Faster feature implementation<\/p>\n

Claude Code successfully implemented complex features like Vim mode with 70% of code written autonomously by Claude.<\/p>\n

Improved development velocity<\/p>\n

The tool rapidly prototypes features and iterates on ideas without getting bogged down in implementation details.<\/p>\n

Enhanced code quality through automated testing<\/p>\n

Claude generates comprehensive tests and handles routine bug fixes, maintaining high standards while reducing manual effort.<\/p>\n

Better codebase exploration<\/p>\n

Team members quickly get up to speed on unfamiliar parts of the monorepo without waiting for colleague responses.<\/p>\n

Top tips from the Claude Code team<\/p>\n

Create self-sufficient loops<\/p>\n

Set up Claude to verify its own work by running builds, tests, and lints automatically. This allows Claude to work longer autonomously and catch its own mistakes, especially effective when you ask Claude to generate tests before writing code.<\/p>\n

Develop task classification intuition<\/p>\n

Learn to distinguish between tasks that work well asynchronously (peripheral features, prototyping) versus those needing synchronous supervision (core business logic, critical fixes). Abstract tasks on the product’s edges can be handled with “auto-accept mode,” while core functionality requires closer oversight.<\/p>\n

Form clear, detailed prompts<\/p>\n

When components have similar names or functions, be extremely specific in your requests. The better and more detailed your prompt, the more you can trust Claude to work independently without unexpected changes to the wrong parts of the codebase.<\/p>\n

Claude Code for security engineering<\/p>\n

The Security Engineering team focuses on securing the software development lifecycle, supply chain security, and development environment security. They use Claude Code extensively for writing and debugging code.<\/p>\n

Main Claude Code use cases<\/p>\n

Complex infrastructure debugging<\/p>\n

When working on incidents, they feed Claude Code stack traces and documentation, asking it to trace control flow through the codebase. This significantly reduces time-to-resolution for production issues, allowing them to understand problems that would normally take 10-15 minutes of manual code scanning in about 5 minutes.<\/p>\n

Terraform code review and analysis<\/p>\n

For infrastructure changes requiring security approval, the team copies Terraform plans into Claude Code to ask “what’s this going to do? Am I going to regret this?” This creates tighter feedback loops and makes it easier for the security team to quickly review and approve infrastructure changes, reducing bottlenecks in the development process.<\/p>\n

Documentation synthesis and runbooks<\/p>\n

Claude Code ingests multiple documentation sources and creates markdown runbooks, troubleshooting guides, and overviews. The team uses these condensed documents as context for debugging real issues, creating a more efficient workflow than searching through full knowledge bases.<\/p>\n

Test-driven development workflow<\/p>\n

Instead of their previous “design doc \u2192 janky code \u2192 refactor \u2192 give up on tests” pattern, they now ask Claude Code for pseudocode, guide it through test-driven development, and periodically check in to steer it when stuck, resulting in more reliable and testable code.<\/p>\n

Context switching and project onboarding<\/p>\n

When contributing to existing projects like “dependant” (a web application for security approval workflows), they use Claude Code to write, review, and execute specifications written in markdown and stored in the codebase, enabling meaningful contributions within days instead of weeks.<\/p>\n

Team impact<\/p>\n

Reduced incident resolution time<\/p>\n

Infrastructure debugging that normally takes 10-15 minutes of manual code scanning now takes about 5 minutes.<\/p>\n

Improved security review cycle<\/p>\n

Terraform code reviews for security approval happen much faster, eliminating developer blocks while waiting for security team approval.<\/p>\n

Enhanced cross-functional contribution<\/p>\n

Team members can meaningfully contribute to projects within days instead of weeks of context building.<\/p>\n

Better documentation workflow<\/p>\n

Synthesized troubleshooting guides and runbooks from multiple sources create more efficient debugging processes.<\/p>\n

Top tips from the security engineering team<\/p>\n

Use custom slash commands extensively<\/p>\n

Security engineering uses 50% of all custom slash command implementations in the entire monorepo. These custom commands streamline specific workflows and speed up repeated tasks.<\/p>\n

Let Claude talk first<\/p>\n

Instead of asking targeted questions to generate code snippets, they now tell Claude Code to “commit your work as you go” and let it work autonomously with periodic check-ins, resulting in more comprehensive solutions.<\/p>\n

Leverage it for documentation<\/p>\n

Beyond coding, Claude Code excels at synthesizing documentation and creating structured outputs. The team provides writing samples and formatting preferences to get documents they can immediately use in Slack, Google Docs, and other tools to avoid interface switching fatigue.<\/p>\n

Claude Code for inference<\/p>\n

The Inference team manages the memory system that stores information while Claude reads your prompt and generates its response. Team members, especially those who are new to machine learning, can use Claude Code extensively to bridge that knowledge gap and accelerate their work.<\/p>\n

Main Claude Code use cases<\/p>\n

Codebase comprehension and onboarding<\/p>\n

The team relies heavily on Claude Code to quickly understand the architecture when joining a complex codebase. Instead of manually searching GitHub repos, they ask Claude to find which files call specific functionalities, getting results in seconds rather than asking colleagues or searching manually.<\/p>\n

Unit test generation with edge case coverage<\/p>\n

After writing core functionality, they ask Claude to write comprehensive unit tests. Claude automatically includes missed edge cases, completing what would normally take a significant amount of time and mental energy in minutes, acting like a coding assistant they can review.<\/p>\n

Machine learning concept explanation<\/p>\n

Team members without a machine learning background depend on Claude to explain model-specific functions and settings. What would require an hour of Google searching and reading documentation now takes 10-20 minutes, reducing research time by 80%.<\/p>\n

Cross-language code translation<\/p>\n

When testing functionality in different programming languages, the team explains what they want to test and Claude writes the logic in the required language (like Rust), eliminating the need to learn new languages just for testing purposes.<\/p>\n

Command recall and Kubernetes management<\/p>\n

Instead of remembering complex Kubernetes commands, they ask Claude for the correct syntax, like “how to get all pods or deployment status,” and receive the exact commands needed for their infrastructure work.<\/p>\n

Team impact<\/p>\n

Accelerated ML concept learning<\/p>\n

With Claude Code, their research time is reduced by 80%, and what historically took an hour of Google searching now takes 10-20 minutes.<\/p>\n

Faster codebase navigation<\/p>\n

The tool can help team members find relevant files and understand system architecture in seconds instead of relying on colleagues to share knowledge, often over the course of several days.<\/p>\n

Comprehensive test coverage<\/p>\n

Claude automatically generates unit tests with edge cases, relieving mental burden while maintaining code quality.<\/p>\n

Language barrier elimination<\/p>\n

The team can implement functionality in unfamiliar languages like Rust without needing to learn it.<\/p>\n

Top tips from the Inference team<\/p>\n

Test knowledge base functionality first<\/p>\n

Try asking various questions to see if Claude can answer faster than Google search. If it’s faster and more accurate, it’s a valuable time-saving tool for your workflow.<\/p>\n

Start with code generation<\/p>\n

Give Claude specific instructions and ask it to write logic, then verify correctness. This helps build trust in the tool’s capabilities before using it for more complex tasks.<\/p>\n

Use it for test writing<\/p>\n

Having Claude write unit tests relieves significant pressure from daily development work. Use this feature to maintain code quality without spending time thinking through all test cases manually.<\/p>\n

Claude Code for data science and ML engineering<\/p>\n

Data Science and ML Engineering teams need sophisticated visualization tools to understand model performance, but building these tools often requires expertise in unfamiliar languages and frameworks. Claude Code enables these teams to build production-quality analytics dashboards without becoming full-stack developers.<\/p>\n

Main Claude Code use cases<\/p>\n

Building JavaScript\/TypeScript dashboard apps<\/p>\n

Despite knowing “very little JavaScript and TypeScript,” the team uses Claude Code to build entire React applications for visualizing Reinforcement Learning (RL) model performance and training data. They give Claude control to write full applications from scratch, like a 5,000-line TypeScript app, without needing to understand the code themselves. This is critical because visualization apps are relatively low context and don’t require understanding the entire monorepo, allowing rapid prototyping of tools to understand model performance during training and evaluations.<\/p>\n

Handling repetitive refactoring tasks<\/p>\n

When faced with merge conflicts or semi-complicated file refactoring that’s too complex for editor macros but not large enough for major development effort, they use Claude Code like a “slot machine” – commit their state, let Claude work autonomously for 30 minutes, and either accept the solution or restart fresh if it doesn’t work.<\/p>\n

Creating persistent analytics tools instead of throwaway notebooks<\/p>\n

Instead of building one-off Jupyter notebooks that get discarded, the team now has Claude build permanent React dashboards that can be reused across future model evaluations. This is important because understanding Claude’s performance is “one of the most important things for the team” – they need to understand how models perform during training and evaluations, which “is actually non-trivial and simple tools can’t get too much signal from looking at a single number go up.”<\/p>\n

Zero-dependency task delegation<\/p>\n

For tasks in completely unfamiliar codebases or languages, they delegate entire implementation to Claude Code, leveraging its ability to gather context from the monorepo and execute tasks without their involvement in the actual coding process. This allows productivity in areas outside their expertise instead of spending time learning new technologies.<\/p>\n

Team impact<\/p>\n

Achieved 2-4x time savings<\/p>\n

Routine refactoring tasks that were tedious but manageable manually are now completed much faster.<\/p>\n

Built complex applications in unfamiliar languages<\/p>\n

Created 5,000-line TypeScript applications despite having minimal JavaScript\/TypeScript experience.<\/p>\n

Shifted from throwaway to persistent tools<\/p>\n

Instead of disposable Jupyter notebooks, now building reusable React dashboards for model analysis.<\/p>\n

Direct model improvement insights<\/p>\n

Firsthand Claude Code experience informs development of better memory systems and UX improvements for future model iterations.<\/p>\n

Enabled visualization-driven decision making<\/p>\n

Better understanding of Claude’s performance during training and evaluations through advanced data visualization tools.<\/p>\n

Top tips from Data Science and ML Engineering teams<\/p>\n

Treat it like a slot machine<\/p>\n

Save your state before letting Claude work, let it run for 30 minutes, then either accept the result or start fresh rather than trying to wrestle with corrections. Starting over often has a higher success rate than trying to fix Claude’s mistakes.<\/p>\n

Interrupt for simplicity when needed<\/p>\n

While supervising, don’t hesitate to stop Claude and ask “why are you doing this? Try something simpler.” The model tends toward more complex solutions by default but responds well to requests for simpler approaches.<\/p>\n

Claude Code for product engineering<\/p>\n

The Product Engineering team works on features like PDF support, citations, and web search that bring additional knowledge into Claude’s context window. Working across large, complex codebases means constantly encountering unfamiliar code sections, spending significant time understanding which files to examine for any given task, and building context before making changes. Claude Code improves this experience by serving as a guide that can help them understand system architecture, identify relevant files, and explain complex interactions.<\/p>\n

Main Claude Code use cases<\/p>\n

First-step workflow planning<\/p>\n

The team uses Claude Code as their “first stop” for any task, asking it to identify which files to examine for bug fixes, feature development, or analysis. This replaces the traditional time-consuming process of manually navigating the codebase and gathering context before starting work.<\/p>\n

Independent debugging across codebases<\/p>\n

The team now has the confidence to tackle bugs in unfamiliar parts of the codebase instead of asking others for help. They can ask Claude “do you think you can fix this bug? This is the behavior I’m seeing” and often get immediate progress, which wasn’t feasible before given the time investment required.<\/p>\n

Model iteration testing through dogfooding<\/p>\n

Claude Code automatically uses the latest research model snapshots, making it their primary way of experiencing model changes. This gives the team direct feedback on model behavior changes during development cycles, which they hadn’t experienced during previous launches.<\/p>\n

Eliminating context-switching overhead<\/p>\n

Instead of copying code snippets and dragging files into Claude.ai while explaining problems extensively, they can ask questions directly in Claude Code without additional context gathering, significantly reducing mental overhead.<\/p>\n

Team impact<\/p>\n

Increased confidence in tackling unfamiliar areas<\/p>\n

Team members can independently debug bugs and investigate incidents in unfamiliar codebases.<\/p>\n

Significant time savings in context gathering<\/p>\n

Claude Code eliminated the overhead of copying code snippets and dragging files into Claude.ai, reducing mental context-switching burden.<\/p>\n

Faster rotation onboarding<\/p>\n

Engineers rotating to new teams can quickly navigate unfamiliar codebases and contribute meaningfully without extensive colleague consultation.<\/p>\n

Enhanced developer happiness<\/p>\n

The team reports feeling happier and more productive with reduced friction in their daily workflows.<\/p>\n

Top tips from the Product Engineering team<\/p>\n

Treat it as an iterative partner, not a one-shot solution<\/p>\n

Rather than expecting Claude to solve problems immediately, approach it as a collaborator you iterate with. This works better than trying to get perfect solutions on the first try.<\/p>\n

Use it for building confidence in unfamiliar areas<\/p>\n

Don’t hesitate to tackle bugs or investigate incidents outside your expertise. Claude Code makes it feasible to work independently in areas that would normally require extensive context building.<\/p>\n

Start with minimal information<\/p>\n

Begin with just the bare minimum of what you need and let Claude guide you through the process, rather than front-loading extensive explanations.<\/p>\n

Claude Code for growth marketing<\/p>\n

The Growth Marketing team focuses on building out performance marketing channels across paid search, paid social, mobile app stores, email marketing, and SEO. As a non-technical team of one, they use Claude Code to automate repetitive marketing tasks and create agentic workflows that would traditionally require significant engineering resources.<\/p>\n

Main Claude Code use cases<\/p>\n

Automated Google Ads creative generation<\/p>\n

The team built an agentic workflow that processes CSV files containing hundreds of existing ads with performance metrics, identifies underperforming ads for iteration, and generates new variations that meet strict character limits (30 characters for headlines, 90 for descriptions). Using two specialized sub-agents (one for headlines, one for descriptions), the system can generate hundreds of new ads in minutes instead of requiring manual creation across multiple campaigns. This has enabled them to test and iterate at scale, something that would have taken a significant amount of time to achieve previously.<\/p>\n

Figma plugin for mass creative production<\/p>\n

Instead of manually duplicating and editing static images for paid social ads, they developed a Figma plugin that identifies frames and programmatically generates up to 100 ad variations by swapping headlines and descriptions, reducing what would take hours of copy-pasting to half a second per batch. This enables 10x creative output, allowing the team to test vastly more creative variations across key social channels.<\/p>\n

Meta Ads MCP server for campaign analytics<\/p>\n

They created an MCP server integrated with Meta Ads API to query campaign performance, spending data, and ad effectiveness directly within the Claude Desktop app, eliminating the need to switch between platforms for performance analysis, saving critical time where every efficiency gain translates to better ROI.<\/p>\n

Advanced prompt engineering with memory systems<\/p>\n

They implemented a rudimentary memory system that logs hypotheses and experiments across ad iterations, allowing the system to pull previous test results into context when generating new variations, creating a self-improving testing framework. This enables systematic experimentation that would be impossible to track manually.<\/p>\n

Team impact<\/p>\n

Dramatic time savings on repetitive tasks<\/p>\n

Claude Code reduced ad copy creation time from 2 hours to 15 minutes, freeing up the team for more strategic work.<\/p>\n

10x increase in creative output<\/p>\n

The team can now test vastly more ad variations across channels with automated ad generation and a Figma integration to source up-to-date visual design elements.<\/p>\n

Operating like a larger team<\/p>\n

The team can handle large development tasks that traditionally required dedicated engineering resources.<\/p>\n

Strategic focus shift<\/p>\n

The team can spend more time on overall strategy and building agentic automation rather than manual execution.<\/p>\n

Top tips from the Growth Marketing team<\/p>\n

Identify API-enabled repetitive tasks<\/p>\n

Look for workflows involving repetitive actions with tools that have APIs (like ad platforms, design tools, analytics platforms). These are prime candidates for automation and where Claude Code provides the most value.<\/p>\n

Break complex workflows into specialized sub-agents<\/p>\n

Instead of trying to handle everything in one prompt or workflow, create separate agents for specific tasks (like a headline agent vs. a description agent). This makes debugging easier and improves output quality when dealing with complex requirements.<\/p>\n

Thoroughly brainstorm and prompt plan before coding<\/p>\n

Spend significant time upfront using Claude.ai to think through your entire workflow, then have Claude.ai create a comprehensive prompt and code structure for Claude Code to reference. Also, work step-by-step rather than asking for one-shot solutions to avoid Claude getting overwhelmed by complex tasks.<\/p>\n

Claude Code for product design<\/p>\n

The Product Design team supports Claude Code, Claude.ai and the Anthropic API, specializing in building AI products. Even non-developers can use Claude Code to bridge the traditional gap between design and engineering, enabling direct implementation of their design vision without extensive back-and-forth iteration with engineers.<\/p>\n

Main Claude Code use cases<\/p>\n

Front-end polish and state management changes<\/p>\n

Instead of creating extensive design documentation and going through multiple rounds of feedback with engineers for visual tweaks (typefaces, colors, spacing), the team directly implements these changes using Claude Code. Engineers noted they’re making “large state management changes that you typically wouldn’t see a designer making,” enabling them to achieve the exact quality they envision.<\/p>\n

GitHub Actions automated ticketing<\/p>\n

Using Claude Code’s GitHub integration, they simply file issues\/tickets describing needed changes, and Claude automatically proposes code solutions without having to open Claude Code, creating a seamless bug-fixing and feature refinement workflow for their persistent backlog of polish tasks.<\/p>\n

Rapid interactive prototyping<\/p>\n

By pasting mockup images into Claude Code, they generate fully functional prototypes that engineers can immediately understand and iterate on, replacing the traditional cycle of static Figma designs that required extensive explanation and translation to working code.<\/p>\n

Edge case discovery and system architecture understanding<\/p>\n

The team uses Claude Code to map out error states, logic flows, and different system statuses, allowing them to identify edge cases during design rather than discovering them later in development, fundamentally improving the quality of their initial designs.<\/p>\n

Complex copy changes and legal compliance<\/p>\n

For tasks like removing “research preview” messaging across the entire codebase, they use Claude Code to find all instances, review surrounding copy, coordinate changes with legal in real-time, and implement updates, a process that took two 30-minute calls instead of a week of back-and-forth coordination.<\/p>\n

Team impact<\/p>\n

Transformed core workflow<\/p>\n

Claude Code became a primary design tool, with Figma and Claude Code open 80% of the time.<\/p>\n

2-3x faster execution<\/p>\n

Visual and state management changes that previously required extensive back-and-forth with engineers are now implemented directly.<\/p>\n

Weeks to hours cycle time<\/p>\n

Complex projects like Google Analytics launch messaging that would take a week of coordination are now completed in two 30-minute calls.<\/p>\n

Two distinct user experiences<\/p>\n

Developers get an “augmented workflow” (faster execution), while non-technical users get a “holy crap, I’m a developer workflow.\u201d<\/p>\n

Improved design-engineering collaboration<\/p>\n

Claude Code enables improved communication and faster problem-solving because designers understand system constraints and possibilities without having to work as closely with engineers.<\/p>\n

Top tips from the product design team<\/p>\n

Get proper setup help from engineers<\/p>\n

Have engineering teammates help with initial repository setup and permissions – the technical onboarding is challenging for non-developers, but once configured, it becomes transformative for daily workflow.<\/p>\n

Use custom memory files to guide Claude’s behavior<\/p>\n

Create specific instructions telling Claude you’re a designer with little coding experience who needs detailed explanations and smaller, incremental changes, dramatically improving the quality of Claude’s responses and making it less intimidating.<\/p>\n

Leverage image pasting for prototyping<\/p>\n

Use Command+V to paste screenshots directly into Claude Code. It excels at reading designs and generating functional code, making it invaluable for turning static mockups into interactive prototypes that engineers can immediately understand and build upon.<\/p>\n

Claude Code for RL Engineering<\/p>\n

The RL Engineering team focuses on efficient sampling in RL and weight transfers across the cluster. They use Claude Code primarily for writing small to medium features, debugging, and understanding complex codebases, with an iterative approach that includes frequent checkpointing and rollbacks.<\/p>\n

Main Claude Code use cases<\/p>\n

Feature development with supervised autonomy<\/p>\n

The team lets Claude Code write most of the code for small to medium features while providing oversight, such as implementing authentication mechanisms for weight transfer components. They work interactively, allowing Claude to take the lead but steering it when it goes off track.<\/p>\n

Test generation and code review<\/p>\n

After implementing changes themselves, the team asks Claude Code to add tests or review their code. This automated testing workflow saves significant time on routine but important quality assurance tasks.<\/p>\n

Debugging and error investigation<\/p>\n

They use Claude Code to debug errors with mixed results. Sometimes it identifies issues immediately and adds relevant tests, while other times it struggles to understand the problem, but overall provides value when it works.<\/p>\n

Codebase comprehension and call stack analysis<\/p>\n

One of the biggest changes in their workflow is using Claude Code to get quick summaries of relevant components and call stacks, replacing manual code reading or extensive debugging output generation.<\/p>\n

Kubernetes operations guidance<\/p>\n

They frequently ask Claude Code about Kubernetes operations that would otherwise require extensive Googling or asking their counterparts in Infrastructure Engineering, getting immediate answers for configuration and deployment questions.<\/p>\n

Development workflow impact<\/p>\n

Experimental approach enabled<\/p>\n

They now use a “try and rollback” methodology, frequently committing checkpoints so they can test Claude’s autonomous implementation attempts and revert if needed, enabling more experimental.<\/p>\n

Documentation acceleration<\/p>\n

Claude Code automatically adds helpful comments that save significant time on documentation, though they note it sometimes adds comments in odd places or uses questionable code organization.<\/p>\n

Speed-up with limitations<\/p>\n

While Claude Code can implement small-to-medium PRs with “relatively little time” from them, they acknowledge it only works on the first attempt about one-third of the time, requiring either additional guidance or manual intervention.<\/p>\n

Top tips from the RL Engineering team<\/p>\n

Customize your Claude.md file for specific patterns<\/p>\n

Add instructions to your Claude.md file to prevent Claude from making repeated tool-calling mistakes, such as telling it to “run pytest not run and don’t cd unnecessarily – just use the right path.” This significantly improved output consistency.<\/p>\n

Use a checkpoint-heavy workflow<\/p>\n

Regularly commit your work as Claude makes changes so you can easily roll back when experiments don’t work out. This enables a more experimental approach to development without risk.<\/p>\n

Try one-shot first, then collaborate<\/p>\n

Give Claude a quick prompt and let it attempt the full implementation first. If it works (about one-third of the time), you’ve saved significant time. If not, then switch to a more collaborative, guided approach.<\/p>\n

Claude Code for Legal<\/p>\n

The Legal team discovered Claude Code’s potential through experimentation and a desire to learn about Anthropic’s product offerings. Additionally, one team member had a personal use case related to creating accessibility tools for family and work prototypes that demonstrate the technology’s power for non-developers.<\/p>\n

Main Claude Code use cases<\/p>\n

Custom accessibility solution for family members<\/p>\n

Team members have built communication assistants for family members with speaking difficulties due to medical diagnoses. In just one hour, one individual created a predictive text app using native speech-to-text that suggests responses and speaks them using voice banks, solving gaps in existing accessibility tools recommended by speech therapists.<\/p>\n

Legal department workflow automation<\/p>\n

The team created prototype “phone tree” systems to help team members connect with the right lawyer at Anthropic, demonstrating how legal departments can build custom tools for common tasks without traditional development resources.<\/p>\n

Team coordination tools<\/p>\n

Managers have built G Suite applications that automate weekly team updates and track legal review status across products, allowing lawyers to quickly flag items needing review through simple button clicks rather than spreadsheet management.<\/p>\n

Rapid prototyping for solution validation<\/p>\n

They use Claude Code to quickly build functional prototypes they can show to domain experts (like showing accessibility tools to UCSF specialists) to validate ideas and identify existing solutions before investing more time.<\/p>\n

Work style and impact<\/p>\n

Planning in Claude.ai, building in Claude Code<\/p>\n

They use a two-step process where they brainstorm and plan with Claude.ai first, then move to Claude Code for implementation, asking it to slow down and work step-by-step rather than outputting everything at once.<\/p>\n

Visual-first approach<\/p>\n

They frequently use screenshots to show Claude Code what they want interfaces to look like, then iterate based on visual feedback rather than describing features in text.<\/p>\n

Prototype-driven innovation<\/p>\n

They emphasize overcoming the fear of sharing “silly” or “toy” prototypes, as these demonstrations inspire others to see possibilities they hadn’t considered.<\/p>\n

Security and compliance awareness<\/p>\n

MCP integration concerns<\/p>\n

Product lawyers use Claude Code to immediately identify security implications of deep MCP integrations, noting how conservative security postures will create barriers as AI tools access more sensitive systems.<\/p>\n

Compliance tooling priorities<\/p>\n

They advocate for building compliance tools quickly as AI capabilities expand, recognizing the balance between innovation and risk management.<\/p>\n

Top tips from the Legal Department<\/p>\n

Plan extensively in Claude.ai first<\/p>\n

Use Claude’s conversational interface to flesh out your entire idea before moving to Claude Code. Then ask Claude to summarize everything into a step-by-step prompt for implementation.<\/p>\n

Work incrementally and visually<\/p>\n

Ask Claude Code to slow down and implement one step at a time so you can copy-paste without getting overwhelmed. Use screenshots liberally to show what you want interfaces to look like.<\/p>\n

Share prototypes despite imperfection<\/p>\n

Overcome the urge to hide “toy” projects or unfinished work. Sharing prototypes helps others see possibilities and sparks innovation across departments that don’t typically interact.<\/p>\n

Get started<\/a> with Claude Code today.<\/p>\n","protected":false},"excerpt":{"rendered":"Anthropic’s internal teams are transforming their workflows with Claude Code, enabling developers and non-technical staff to tackle complex…\n","protected":false},"author":2,"featured_media":35585,"comment_status":"","ping_status":"","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[45],"tags":[182,181,507,74],"class_list":["post-35584","post","type-post","status-publish","format-standard","has-post-thumbnail","category-artificial-intelligence","tag-ai","tag-artificial-intelligence","tag-artificialintelligence","tag-technology"],"_links":{"self":[{"href":"https:\/\/www.newsbeep.com\/us\/wp-json\/wp\/v2\/posts\/35584","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.newsbeep.com\/us\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.newsbeep.com\/us\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.newsbeep.com\/us\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.newsbeep.com\/us\/wp-json\/wp\/v2\/comments?post=35584"}],"version-history":[{"count":0,"href":"https:\/\/www.newsbeep.com\/us\/wp-json\/wp\/v2\/posts\/35584\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.newsbeep.com\/us\/wp-json\/wp\/v2\/media\/35585"}],"wp:attachment":[{"href":"https:\/\/www.newsbeep.com\/us\/wp-json\/wp\/v2\/media?parent=35584"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.newsbeep.com\/us\/wp-json\/wp\/v2\/categories?post=35584"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.newsbeep.com\/us\/wp-json\/wp\/v2\/tags?post=35584"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}