This blog post is Human-Centered Content: Written by humans for humans.

What would change if you could run five projects at once instead of one?

That’s not a hypothetical. It’s how the team that built Claude Code uses it. And over the past year, we’ve been testing whether those patterns translate outside a Silicon Valley AI lab.                                    

They do.   

The required setup isn’t complex. Like the Claude Team, our internal setups are “surprisingly vanilla.” No exotic customizations. No secret hacks. Just disciplined application of fundamentals that most people skip right past.

The best news? Claude Code isn’t just for developers. Consultants, analysts and project managers across our company are using it as a general-purpose agent to automate and accelerate their work. The lessons overlap heavily with what Boris Cherny (Claude Code’s creator) and his team shared, so I wanted to unpack the highlights and add our perspective.

But first, if you’re new to this world: What is Claude Code, and why should you care?

Claude Code in 30 Seconds

Claude Code is an AI-powered coding agent built by Anthropic that lives in your terminal (or browser or phone). Unlike a chatbot where you type a question and get a response, Claude Code is an agent. It can read your entire codebase, run commands, execute tests, commit code and use external tools. You give it a task and it works through it autonomously, iterating until it’s done.

Think of it less like talking to an AI and more like delegating to an extremely fast junior engineer who never sleeps and reads documentation at inhuman speed. The catch is that like any junior engineer, it needs good direction. The quality of what you get out depends heavily on how you set it up and what you ask it to do.

That’s what this post is about.

Plan Before You Code

Claude Code has a very useful plan mode and this is a great place to start. Go back and forth with Claude until you like its plan, then switch to auto-accept edits mode and watch it fly. This is the key to get Claude to work for longer periods of time while achieving higher quality outputs. Claude will turn the plan into discrete tasks and begin to implement them one-by-one. 

To take this a step further, we’ve been using other instances of Claude (or even other models like Gemini or Codex) to review that plan “as a Staff Engineer.” The reviewer pokes holes, identifies edge cases and flags assumptions that might not hold. It’s like getting a design review before you’ve written a single line of code, except it takes five minutes instead of scheduling a meeting.

Use Subagents to Keep Your Context Clean

Here’s a concept that trips up new Claude Code users: context windows are finite. Every file Claude reads, every error message it processes, every conversation turn eats into that space. When it fills up, Claude starts losing track of earlier instructions and decisions.

Subagents solve this. When you append “use subagents” to a request that involves heavy research or multi-step work, Claude offloads those individual tasks to isolated sub-agents. Each one works independently and returns only the distilled results to your main session. Your primary context window stays clean and focused.

A common two-agent pattern we use is having one agent create a detailed plan and roadmap and another “coder” agent that implements. It sounds redundant until you see how much rework it prevents. We’re starting to take this even further with a 3^rd agent responsible for QA that can run Playwright or Claude for Chrome to simulate user testing.

Boris and the Claude team extensively use subagents for repeatable workflows like code simplification and end-to-end verification. Tasks that generate a lot of context noise but produce a concise outcome. The Claude Code team even open-sourced their code-simplifier agent as a plugin you can install.

Think of it like delegation. Instead of one person reading every document and attending every meeting, you’ve got specialists handling discrete pieces and reporting back.

Invest in Your CLAUDE.md

This is the tip that separates teams that get good results from teams that get great ones.

CLAUDE.md is a file that Claude Code reads on startup. It contains project context, conventions, common mistakes to avoid and any other instructions you want Claude to follow. Every team should maintain its own CLAUDE.md, checked into Git, with the whole team contributing multiple times a week. That accumulated learning compounds into better results.

The key practice: When Claude makes a mistake, correct it and then tell it to update the CLAUDE.md so it doesn’t make that mistake again. Over time, your CLAUDE.md becomes a refined instruction set that reflects the specific patterns and gotchas of your project. It gets smarter because you make it smarter.

We iterate on our CLAUDE.md files ruthlessly at InterWorks. Teams that invest here consistently outperform teams that don’t, even running the exact same model.

Build Skills and Reuse Them

Going a step beyond the Claude.md files, Skills are reusable instruction sets you can create, commit to Git, and share across projects that help you define key processes and capabilities. Think of them as modular chunks of a CLAUDE.md that Claude can load when they’re relevant rather than reading everything every time.

The Best Practice: If you find yourself telling Claude to do the same thing more than once a day, turn it into a skill. We’ve built a /interworks-powerpoint command that allows us to turn presentation outlines into branded decks using our standard template. You can use skills to do all kinds of things like standardize your “company voice” in writing,  enforce coding standards during reviews, and create data visualizations in a standard style.

Because skills are a single file, they can live in a project, shared easily and even served via an MCP Server. New team members get the benefit of every workflow your team has refined. This is one of those investments that compounds. The more skills you build, the more capable your Claude Code environment becomes.

But custom skills are only part of the story. Claude Code ships with built-in skills worth knowing about. One of the most impactful for us has been the frontend-design skill. It pushes Claude to make bold, intentional design choices rather than producing the generic “AI-built” look that plagues so many generated interfaces. When we run workshops, the difference between a website built with and without this skill is obvious. It’s one of the first things we tell people to try.

There’s also a growing ecosystem of community-built skills that extend Claude Code into many other domains. One we’ve been watching is mviz, a chart and report builder designed specifically for AI-driven workflows. Instead of writing 50-100 lines of chart boilerplate, you write a compact spec and mviz generates polished HTML reports with ECharts visualizations. It pairs naturally with tools like DuckDB for data exploration: Query your data, build context, then tell Claude to “use mviz to report on this analysis.” For data teams, this is a glimpse of where things are heading.

Curated directories like awesome-claude-skills and marketplaces like SkillsMP are cataloging thousands of community skills across categories from data visualization to DevOps to scientific research. It’s still early days, but the pattern is clear: Skills are becoming the way you define what good work looks like and they are essential. The teams that learn to discover, evaluate and integrate community skills alongside their own custom ones will have a significant edge.

Challenge Claude

Most people under-prompt Claude Code. They ask for changes and accept whatever comes back. You can push it harder, and you should. Claude is a great sparring partner.

Three helpful prompts from the Claude Code team that we also leverage:

“Grill me on these changes…until I pass your test.” This flips the dynamic. Instead of you reviewing Claude’s work, Claude reviews yours. It forces critical thinking about what you’re shipping and catches things you might have glossed over.

“Knowing everything you know now, scrap this and implement the elegant solution.” Just like a human, the first solution is often just a good rough draft. Ask Claude to improve and refine. Even better if you can provide insight and critiques.

“Prove to me this works.” Don’t accept Claude’s word that a change is correct. Make it demonstrate correctness. Run the tests, show the output, explain why the edge cases are handled. Adding regular QA to my workflows has increased the quality of outputs and reduced the time I was working through broken solutions.

These are further enhanced when you combine them with some common prompt patterns we advise people to adopt internally:

• Flipped Interaction – Let Claude interview you to gather requirements. It often knows what info it needs better than you do.
• Chain of Thought – Ask Claude to show its reasoning step by step. Improves accuracy and lets you verify the logic.
• Persona – Give Claude a specific role or expertise to shape its responses and activate relevant knowledge.
• Pre-Mortem – Imagine a project has failed and work backward to identify risks and blind spots.
• Multiple Variations – Request several distinct options to compare rather than a single “best” answer.

Set Up Your Environment Right

A few practical environment tips from the Claude Code team and our own experience:

Interface matters. We’ve set up people to use VS Code and the Claude Chrome extension so people feel more comfortable and at home. A growing number of people are purely using a Terminal, however, and the Claude Code team recommends Ghostty for its synchronized rendering and proper Unicode support. When you’re running multiple sessions in parallel, a terminal that renders cleanly makes a noticeable difference.

Manage Your Context. Context management is one of the most important skills in working with Claude Code, and one of the least obvious. This is why techniques like subagents can work so well. Set up /statusline to inform you of token use so you know when you’re approaching limits before Claude starts forgetting your earlier instructions. Use /clear when you’re starting new features or different tasks so you don’t waste your token on old work.

Learn while you work. Yes, you can use AI to help you learn. Use /config to set output styles like “Explanatory” or “Learning” mode so Claude explains the reasoning behind its changes rather than just making them. You can also ask it to generate visual HTML presentations to walk through unfamiliar code. It’s like having a patient senior engineer who never gets tired of your questions. Combined with the earlier tip to push back on Claude and you’ll improve your thinking as you wrestle and understand the problems you’re solving.

Work in Parallel

If I could give you a single tip, it’s this: Expand from working in one session at a time to running them in parallel.

It’s common for power users to be running five or more Claude Code sessions simultaneously using system notifications alerting you when any session needs input. This can be a mix of terminal, browser and even the phone. Last week, I added charts to some admin reports for an internal site from my phone while at a restaurant when an idea struck me.

If you’re code-heavy and working on a single code base, an essential mechanism to make this work is git worktrees. A worktree lets you check out multiple branches from the same repository into separate directories. Each gets its own working directory with isolated files while sharing the same Git history. You can run multiple Claude instances simultaneously: one refactoring authentication, another building a dashboard component, a third writing tests. They don’t step on each other.

The beautiful thing is you can ask Claude to help set this up.

Moving to multiple, parallel agents is the single biggest productivity shift we’ve seen at InterWorks. It turns Claude Code from a fast assistant into something closer to a small team. The people who adopted parallel workflows early consistently report the largest gains.

For Data Teams: You’re Not Left Out

If you’re in data or analytics and given that this is InterWorks there’s a good chance you are, Claude Code isn’t just for building web apps. Tableau has an MCP Server that will allow you to search for analytics, do admin tasks, and even pull data from your Tableau hosted datasets and connections. dbt has an MCP server as well. Beyond MCP servers, Claude Code is excellent at building dashboards in code, such as Streamlit that you can easily deploy into Snowflake

This connects to something I wrote about last year, the gap between what AI agents can do with code versus what they can do with data. That gap is narrowing. Tools like Claude Code are making it practical for data professionals to work in code without needing to become software engineers. Skills and MCP servers are beginning to help Claude speak the language of data and analytics.

The Pattern Underneath

If there’s a common thread running through everything Boris shared and everything we’ve learned, it’s this: The people who get the most out of Claude Code treat it as infrastructure, not magic.

That means investing in the systems around it: Memory files that accumulate knowledge, skills that encode best practices, verification loops that catch mistakes, parallel workflows that multiply throughput, and tools that extend its impact and reach. It means holding Claude to a high standard rather than accepting whatever it produces on the first pass.

The great thing about Claude Code is that it’s flexible. There’s no single “right way” to use it. Each person on the team uses it differently and adapts it to their needs, but the fundamentals (plan first, work in parallel, invest in context, verify everything) are consistent across every high-performing workflow we’ve seen.

We’ve watched this pattern play out across our company. Developers shipping features faster. Non-technical team members building tools they never could have built before. The capabilities are real. The question is whether you’re set up to use them.

If your team is curious about Claude Code and wants help getting started, from initial setup to workshops to building the skills and integrations that make it stick, we’re here to figure it out together.