Claude Code Setup - One Agent Better Than Fifteen

Boris Cherny, the creator of Claude Code, runs 10-15 sessions in parallel.

Five in his terminal. Five to ten on the web. A few more on his phone throughout the day.

He describes his setup as “surprisingly vanilla.” Most people would call it overkill.

I’ve used Claude Code extensively. It’s honestly a bit more complicated than using the usual Claude Desktop. But it’s also quite powerful—it can read files, edit them, and save them directly on your PC without having to go back and forth attaching.

After watching Cherny’s podcast explaining his workflow, I have a different take: You don’t need fifteen sessions. You need one agent with a well-detailed workflow.

From my experience with Claude Code and tools like OpenClaw, one agent with multiple identities and detailed markdown files can take on different hats and follow a blueprint. That’s smarter than juggling fifteen parallel sessions.

But some of Cherny’s tips are genuinely valuable. Plan Mode is a real productivity boost—though it burns tokens faster. MCP servers connecting Claude to Slack, GitHub, and Google Drive? That’s powerful automation. That’s exactly why there’s so much fuss about Claude Code.

And the CLAUDE.md file concept—treating every mistake as a rule so Claude doesn’t repeat errors—is smart knowledge management, not technical debt.

Claude Code is revolutionary for developers. But it’s also revolutionary for non-technical people, because it gives them access to technical power without necessarily having to know how to code.

Let me explain what Claude Code actually is, why the 15-session setup is overkill, which tips are worth adopting, and why non-developers should care about agentic coding tools.

What Is Claude Code? (Simple Explanation)

Claude Code is Anthropic’s agentic coding tool that lives in your terminal.

You talk to it in plain English. It writes, tests, and ships code.

Instead of writing code yourself, you describe what you want. Claude Code generates it, runs it, debugs it, and saves it to your project files—all without you touching a code editor.

How it started

Claude Code began as a side project by Boris Cherny, a former Meta engineer, during his first month at Anthropic.

When shared internally, Anthropic’s engineers quickly adopted it. Over 80% of the company’s engineers were using it daily before the public launch in May 2025.

That adoption rate at a company building AI models tells you something about the tool’s utility.

Why it’s more powerful than Claude Desktop

Claude Desktop is simpler. You chat with Claude in a desktop app. It can read files you attach, but you have to manually copy code back into your editor.

Claude Code is more complicated. But it’s also more powerful:

Reads files directly from your project
Edits those files in place
Saves changes without you copying/pasting
Runs terminal commands (builds, tests, deployments)
Connects to external tools via MCP servers

The friction is lower. The automation is higher.

The 15-Session Setup: Impressive But Overkill

Boris Cherny runs 10-15 Claude Code sessions simultaneously.

His workflow

Terminal: 5 sessions in parallel, numbered tabs 1-5 Web: 5-10 sessions running on claude.ai Phone: A few sessions started in the morning, checked throughout the day

He uses iTerm2 system notifications that ping him when a session finishes or needs input.

He hands off local sessions to the web using –teleport, then pulls them back when needed.

Is this genius productivity or showing off?

From my experience with Claude Code and tools like OpenClaw, you really just need one agent with a well-detailed workflow within the files and multiple identities to represent different agents.

This way, one agent can take on different hats. With detailed markdown files, it can always follow a sort of blueprint.

Why one agent is smarter than fifteen

Multiple sessions make sense if you’re working on completely unrelated tasks across different codebases.

But for most developers—even those working on large projects—one well-configured agent with clear instructions handles the job better.

Here’s why:

Context retention: One agent maintains full context of your project. Fifteen agents fragment that context.

Workflow clarity: One agent following a detailed CLAUDE.md knows the project’s rules. Fifteen agents each need separate instruction.

Token efficiency: One agent reusing learned patterns is cheaper than fifteen agents learning independently.

Mental overhead: Managing fifteen sessions—even with notifications—creates cognitive load. One agent with multiple identities (different roles: backend dev, frontend dev, tester) in sequence is cleaner.

The creator’s workflow reflects his role at Anthropic—working on a massive codebase with an engineering team where different people might pick up different sessions. For individual developers or small teams, it’s overkill.

Plan Mode: Genuine Boost, But Token-Heavy

One tip worth adopting: Start every session in Plan Mode.

How Plan Mode works

Hit Shift + Tab twice to enter Plan Mode.

This is a read-only mode where Claude explores your codebase and reasons through the problem without making changes.

You iterate on the plan together until it looks right. Then flip to auto-accept and let Claude build it in one go.

Why this is genuinely useful

You know exactly what Claude is going to build before it starts. That saves you from fixing unexpected outputs later.

It’s a good boost to ensure better results.

The downside: Token consumption

What I found out is that one can also use various plugins like Superpowers to give Claude that extra productivity boost.

The downside? More tokens are used, causing rate limits to hit faster.

Plan Mode explores the entire codebase, reads relevant files, reasons through implementation details. That burns through your token allocation quickly.

If you’re on Claude Pro with higher limits, this isn’t a problem. If you’re on free tier or hitting rate limits, you’ll need to use Plan Mode selectively for complex tasks.

But the tradeoff is worth it for important features where getting it right the first time matters more than token cost.

MCP Servers: Powerful Automation (Why There’s Fuss)

Here’s the real reason Claude Code is revolutionary: MCP servers.

What MCP servers do

MCP (Model Context Protocol) lets Claude Code connect to external tools and take actions within them.

Not just read data. Actually take action.

Examples:

Search and post to Slack
Open pull requests on GitHub
Query databases with BigQuery
Pull error logs from Sentry
Access and edit Google Drive documents
Design in Canva

Why this is powerful automation

That is powerful automation. That’s exactly why there’s so much fuss about Claude Code.

Traditional automation requires you to write scripts, configure API calls, handle authentication, manage errors.

MCP abstracts all that away. You tell Claude “post this update to the #engineering Slack channel” and it handles the API interaction.

MCP is an open standard

Anyone can build an MCP server. If there isn’t one for a tool you use, you can create it.

Boris Cherny’s team at Anthropic checks their MCP configuration into a shared .mcp.json file. The entire team gets the same integrations automatically.

After hearing about this workflow, I started connecting a lot of my own tools to Claude through MCP. It massively reduced the context switching I used to do.

The governance question

Is it concerning that an AI agent can post to Slack and run database queries?

It’s powerful. It’s also why governance matters.

You configure which tools Claude can access. You set permissions. You review actions before they execute (or enable auto-accept for trusted operations).

The power is real. The risk is manageable with proper configuration.

CLAUDE.md: Smart Knowledge Management

The CLAUDE.md file concept is brilliant: treat every mistake as a rule.

What CLAUDE.md is

A markdown file in your project root that Claude Code reads at the beginning of every session.

It’s like explaining your entire workflow to a new developer joining your team, except you only have to do it once—and it improves over time.

How to use it

Start with essentials:

What language and framework you’re using
How to build and test
Style preferences
File structure conventions

Then, every time Claude does something wrong—uses the wrong library, formats code differently than you’d like, puts files in the wrong place—add a line.

Example:

# CLAUDE.md

## Project Setup
- Language: TypeScript
- Framework: React with Next.js
- Testing: Jest + React Testing Library

## Rules
- Always use named exports, never default exports
- Place all API calls in /lib/api/
- Format with Prettier before committing
- Never import from index files directly

## Common Mistakes
- Don't use axios, we use fetch
- Don't create .jsx files, use .tsx
- Don't put styles in components, use /styles/

The file compounds over time. Eventually, Claude just works the way you want it to.

Why this is smart knowledge management, not technical debt

Smart knowledge management.

Technical debt accumulates when you patch problems without addressing root causes. CLAUDE.md does the opposite—it documents root causes so problems don’t recur.

It’s a living style guide that every session inherits. That ensures consistency across your project while saving hours of corrections.

Boris Cherny’s team shares a single CLAUDE.md for their entire repo. The whole team contributes multiple times per week.

Any time Claude does something wrong, they add a note. That prevents the entire team from encountering the same issue.

That’s distributed knowledge management, not debt.

Why Claude Code Is Revolutionary

Is Claude Code actually revolutionary for developers, or just another tool that gets hyped because it’s from Anthropic?

It’s revolutionary for sure.

What makes it revolutionary

Not the individual features. Those exist elsewhere:

GitHub Copilot autocompletes code
Cursor does AI pair programming
Replit Agent builds apps from prompts

Claude Code’s revolution is integration depth.

It doesn’t just suggest code. It reads your entire project, understands your conventions (via CLAUDE.md), executes terminal commands, runs tests, connects to external tools (via MCP), and iterates autonomously until the task is complete.

That end-to-end agency is new.

The comparison to ChatGPT’s launch

The article compares Claude Code to ChatGPT’s launch—”the thing everyone’s talking about, whether they fully understand it or not.”

That’s accurate.

ChatGPT made conversational AI accessible. Claude Code makes agentic coding accessible.

Both represent step-function improvements in what non-experts can accomplish with AI assistance.

Why Non-Developers Should Care

For non-developers reading this blog: Why should they care about Claude Code setup tips beyond “coders are using AI now”?

Because it accelerates building at a much faster scale and gives non-technical people access to technical power without necessarily having to know how to code.

What this means practically

Before Claude Code: You have an idea for a web app. You need to:

Learn to code, or
Hire a developer, or
Use a no-code tool with severe limitations

With Claude Code: You describe what you want. Claude Code builds it.

Not perfectly. Not for production-ready enterprise software. But for prototypes, internal tools, automation scripts, data analysis—it works.

Real-world examples

Non-technical founder: Builds MVP for startup without hiring developer. Validates product-market fit before raising funding.

Operations manager: Automates report generation that previously required manual data entry. Saves 10 hours per week.

Marketing analyst: Creates custom dashboard pulling data from Google Analytics, Salesforce, and social media APIs. No SQL knowledge required.

Researcher: Writes scripts to scrape data, clean it, and generate visualizations. No Python experience needed.

These aren’t hypothetical. These are happening now.

The democratization of technical capability

That’s the revolutionary part.

Not that developers can code faster. They can—but incremental speed improvements aren’t revolutionary.

The revolution is non-technical people gaining technical capabilities they couldn’t access before.

Similar to how ChatGPT democratized content creation (anyone can now write decent copy), Claude Code democratizes software development (anyone can now build decent tools).

That shifts what’s possible for individuals and small teams without technical co-founders or large engineering budgets.

What This Really Means

Claude Code is revolutionary agentic coding tool that lives in terminal. Creator runs 15 sessions in parallel, but that’s overkill—one agent with detailed workflow and multiple identities is smarter. Real power comes from MCP automation and CLAUDE.md knowledge management. Non-technical people now have access to technical capabilities.

Here’s what we know:

Claude Code more complicated than Desktop but more powerful. Can read files, edit them, save directly on PC without back-and-forth attaching. Runs terminal commands, builds, tests, deployments. Lower friction, higher automation than desktop version.

15-session setup impressive but unnecessary for most developers. Creator’s workflow (5 terminal, 5-10 web, phone sessions) reflects massive Anthropic codebase with team. For individuals/small teams, one agent with well-detailed workflow and multiple identities smarter approach.

One agent better than fifteen for most cases. Context retention (one agent maintains full context vs fragmented across fifteen), workflow clarity (one CLAUDE.md vs separate instructions), token efficiency (reusing learned patterns cheaper), mental overhead (managing fifteen sessions creates cognitive load).

Plan Mode genuine productivity boost but token-heavy. Shift + Tab twice enters read-only mode where Claude explores codebase and reasons without changes. Iterate on plan, then build. Ensures better results, prevents fixing unexpected outputs. Downside: burns through token allocation quickly hitting rate limits faster.

MCP servers are why there’s fuss. Powerful automation—not just reading data but taking actions. Post to Slack, open GitHub PRs, query databases, pull error logs, edit Google Drive, design in Canva. Abstracts away API scripts/authentication/error handling. Open standard anyone can build.

MCP massively reduces context switching. Started connecting own tools through MCP after learning creator’s workflow. Power is real, risk manageable with proper permissions configuration.

CLAUDE.md smart knowledge management not technical debt. Markdown file in project root Claude reads every session. Start with essentials (language, framework, build/test, style), add rule every time Claude makes mistake. File compounds over time, prevents recurring errors.

Why it’s knowledge management: Documents root causes so problems don’t recur, living style guide every session inherits, ensures consistency saves hours corrections. Boris’s team shares single file, whole team contributes weekly. Distributed knowledge management.

Claude Code revolutionary not hyped. Revolution is integration depth—reads entire project, understands conventions (CLAUDE.md), executes commands, runs tests, connects external tools (MCP), iterates autonomously until complete. End-to-end agency is new capability.

Comparison to ChatGPT launch accurate. ChatGPT made conversational AI accessible, Claude Code makes agentic coding accessible. Both step-function improvements in what non-experts accomplish with AI.

Non-technical people get technical power. Build MVPs without hiring developers, automate reports saving 10 hours/week, create custom dashboards without SQL, write data scripts without Python. Not hypothetical—happening now.

Democratization of technical capability is revolution. Not incremental developer speed improvement. Non-technical people gaining capabilities they couldn’t access before. Similar to ChatGPT democratizing content creation, Claude Code democratizes software development.

Shifts what’s possible for individuals and small teams without technical co-founders or large engineering budgets. Revolutionary impact for accessibility not just productivity.

Bottom line: Claude Code revolutionary tool. Creator’s 15-session setup overkill for most. Real power: MCP automation (take actions in external tools), CLAUDE.md knowledge management (prevent recurring errors), technical capability access for non-coders. Changes who can build software.