How to Set Up Claude Code for Real Projects: MCP, CLAUDE.md, and Sub-Agents
By Ashish Singh
July 13, 2026
Table of Contents
You want to use Claude Code for development. Furthermore, basic setup is straightforward. Moreover, production setup is different. Additionally, most developers skip critical configuration steps.
This article explains how to configure Claude Code properly. Furthermore, we cover MCP servers, CLAUDE.md files, and sub-agents. Moreover, we show you how production teams use Claude Code effectively. Additionally, we provide templates and checklists you can use immediately.
Research shows that 71% of developers using AI agents prefer Claude Code for real projects. Furthermore, the difference between basic and production setup is dramatic. Moreover, developers using full configuration report 3x faster development cycles. Additionally, code quality improves when you implement proper workflows.
The key insight is this: Claude Code becomes powerful when you configure it for your specific context. Furthermore, basic chatbot use wastes the tool’s potential. Moreover, proper setup transforms Claude Code into a development partner that understands your codebase and processes.
For organizations implementing generative AI development workflows, Claude Code setup is foundational to enterprise AI strategy. Furthermore, your configuration determines your team’s productivity. Moreover, small upfront investment in setup pays enormous dividends.
By the end of this guide, you will have a working Claude Code setup for real projects.
Claude Code is an AI-powered coding assistant built directly into Anthropic’s development environment. Furthermore, it goes beyond basic code completion. Moreover, it understands your entire codebase and development context. Additionally, it can autonomously write, test, and debug code.
Claude Code is not just a smarter autocomplete. Furthermore, it understands the relationship between files and components. Moreover, it maintains context across conversations and sessions. Additionally, it integrates with your development workflow rather than interrupting it.
Compared to GitHub Copilot, Claude Code provides deeper reasoning about code structure. Furthermore, it asks clarifying questions before implementing. Moreover, it understands project architecture better. Additionally, it produces fewer hallucinations and errors.
Compared to Cursor, Claude Code provides more flexibility in configuration. Furthermore, you control exactly how it accesses your codebase. Moreover, you can add specialized tools and integrations. Additionally, you maintain data privacy through MCP configuration.
Basic Claude Code usage works but leaves 70% of capability unused. Furthermore, you are essentially running a chatbot that happens to understand code. Moreover, you are not getting the full power of AI-assisted development.
Proper configuration changes everything. Furthermore, Claude Code becomes aware of your project structure. Moreover, it understands your coding standards and conventions. Additionally, it can delegate tasks to specialized sub-agents. Furthermore, it integrates with your version control, testing, and deployment systems.
Teams that configure Claude Code report 40-60% faster feature development. Furthermore, code quality improves because Claude Code understands your standards. Moreover, bugs decrease because testing integrates automatically. Additionally, team knowledge improves because documentation generation works seamlessly.
This guide walks you through complete production setup. Furthermore, we cover installation and basic configuration. Moreover, we explain MCP servers and how to connect them. Additionally, we show you how to write effective CLAUDE.md files. Furthermore, we explain sub-agents and specialized workflows.
Claude Code is available as a command-line tool that integrates with your development environment. Furthermore, installation takes 5-10 minutes. Moreover, you need Node.js 18+ installed first. Additionally, the tool works on Windows, Mac, and Linux.
Start by opening your terminal. Furthermore, run this command to install Claude Code globally:
npm install -g @anthropic-ai/claude-code
After installation, verify it works by running:
claude-code –version
This should display the version number. Furthermore, if you see an error, Node.js may not be installed correctly. Moreover, visit nodejs.org if you need to install or upgrade Node.js.
Next, authenticate your account. Furthermore, run:
claude-code auth
This opens your browser to authenticate with Anthropic. Moreover, follow the prompts to log in. Additionally, your authentication token saves locally for future sessions.
MCP stands for Model Context Protocol. Furthermore, it is how Claude Code connects to external tools and data sources. Moreover, MCP servers act as bridges between Claude Code and your systems. Additionally, they let Claude Code access databases, APIs, documentation, and repositories.
Think of MCP servers as specialized extensions. Furthermore, each server provides specific capabilities. Moreover, you can enable only the servers you need. Additionally, this keeps your setup focused and secure.
Common MCP servers include:
MCP servers run as separate processes. Furthermore, Claude Code communicates with them through standardized protocols. Moreover, this isolation provides security and reliability. Additionally, servers can run locally or remotely.
Most MCP configuration happens in a config file called .claude/config.json. Furthermore, you create this file in your project root. Moreover, it specifies which servers Claude Code should access. Additionally, it defines permissions and connection details.
Here is a basic MCP configuration:
{
“mcp_servers”: [
{
“name”: “github”,
“type”: “stdio”,
“command”: “npx”,
“args”: [“@anthropic-ai/mcp-server-github”],
“enabled”: true,
“config”: {
“repository”: “your-username/your-repo”,
“token”: “${GITHUB_TOKEN}”
}
},
{
“name”: “filesystem”,
“type”: “stdio”,
“command”: “npx”,
“args”: [“@anthropic-ai/mcp-server-fs”],
“enabled”: true,
“config”: {
“root”: “./src”
}
}
]
}
This configuration enables GitHub integration and file system access. Furthermore, the GitHub server needs a personal access token. Moreover, you set this as an environment variable GITHUB_TOKEN. Additionally, the file system server limits access to the ./src directory for security.
To implement this, follow these steps:
First, create the .claude directory:
mkdir -p .claude
Second, create the config.json file with the content above. Furthermore, adjust the repository name and token references for your situation. Moreover, add additional MCP servers as needed. Additionally, save the file.
Third, set your GitHub token as an environment variable:
export GITHUB_TOKEN=your_personal_access_token
Fourth, test the configuration by running Claude Code in your project:
claude-code start
Claude Code should load without errors. Furthermore, it should recognize the MCP servers. Moreover, you should see connection confirmations in the startup output. Additionally, this means your MCP configuration works correctly.
Keep sensitive data out of version control. Furthermore, use environment variables for tokens and credentials. Moreover, add .claude/config.json to your .gitignore if it contains secrets. Additionally, consider a .claude/config.template.json for sharing non-sensitive configuration.
Enable only the MCP servers you need. Furthermore, each additional server increases startup time and complexity. Moreover, limited servers reduce security surface area. Additionally, focus on servers that add real value to your workflow.
Document why each server is enabled. Furthermore, future team members need to understand the configuration. Moreover, comments in your config file help. Additionally, a README explaining your MCP setup prevents confusion.
CLAUDE.md is a special file that contains project-specific instructions for Claude Code. Furthermore, it works like a permanent system prompt for your repository. Moreover, you write it once and Claude Code reads it every session. Additionally, this eliminates the need to repeat instructions constantly.
The impact is enormous. Furthermore, developers using CLAUDE.md reduce prompt repetition by up to 80%. Moreover, code consistency improves because Claude Code understands your standards. Additionally, onboarding new team members becomes faster because Claude Code can teach them your conventions.
Your CLAUDE.md file should include several sections. Furthermore, start with project overview. Moreover, add coding standards and conventions. Additionally, explain testing and documentation practices. Furthermore, specify deployment procedures. Moreover, include common issues and solutions.
Here is a template CLAUDE.md file:
# Project Context: MyApp Backend API
## Project Overview
MyApp is a real-time collaborative platform built with Node.js and React. The backend serves REST APIs for authentication, data management, and notifications. The frontend provides a responsive UI for desktop and mobile users.
## Technology Stack
– Backend: Node.js 20.x with Express.js
– Database: PostgreSQL 15 with Prisma ORM
– Testing: Jest for unit tests, Cypress for integration tests
– Deployment: Docker containers on Kubernetes
– Monitoring: DataDog for observability
## Code Organization
src/ routes/ # Express route handlers controllers/ # Business logic services/ # Data access and external APIs middleware/ # Authentication, validation, logging types/ # TypeScript interfaces and types tests/ # Unit and integration tests utils/ # Helper functions
## Coding Standards
– Use TypeScript for all new code
– Follow ESLint configuration in .eslintrc.json
– Functions should be under 30 lines when possible
– Always include JSDoc comments for public functions
– Use async/await instead of .then() chains
– Handle errors explicitly with try-catch blocks
## Testing Requirements
– Write unit tests for all utility functions
– Aim for 80%+ code coverage
– Integration tests required for API endpoints
– Mock external services in tests
– Run `npm test` before committing
## Git Conventions
– Branch naming: feature/name or bugfix/name
– Commits: Use present tense (“add feature” not “added feature”)
– Pull requests require approval from one senior developer
– Squash commits before merging to main
## Common Issues and Solutions
– PostgreSQL connection failures: Check DATABASE_URL environment variable
– Port 3000 in use: Kill existing process or use different port
– Tests failing locally: Clear node_modules and reinstall dependencies
## Deployment Process
This template covers what Claude Code needs to know. Furthermore, it takes 20-30 minutes to write the first time. Moreover, you update it as standards change. Additionally, the time investment pays huge dividends.
Your project overview should explain what the project does and why. Furthermore, Claude Code uses this to understand context. Moreover, include relevant background information. Additionally, keep it under 5 sentences.
Your technology stack section should list all major tools and versions. Furthermore, Claude Code uses this to understand your constraints. Moreover, include versions because Claude Code suggests version-appropriate solutions. Additionally, note any unusual choices and explain why you made them.
Your code organization section should match your actual directory structure. Furthermore, Claude Code uses this to understand where to find things. Moreover, explain why you organized code this way. Additionally, mention any special files or configurations.
Your coding standards section is the most important. Furthermore, this is where you enforce consistency. Moreover, list specific rules about naming, formatting, and structure. Additionally, reference configuration files like ESLint or Prettier.
Your testing requirements section specifies what Claude Code should generate. Furthermore, this prevents untested code. Moreover, state coverage targets explicitly. Additionally, mention frameworks and tools you use.
Once you create CLAUDE.md, place it in your project root. Furthermore, Claude Code reads it automatically at startup. Moreover, Claude Code follows the instructions when writing code. Additionally, this creates consistent code that matches your standards.
When Claude Code suggests code that violates your CLAUDE.md standards, point this out. Furthermore, Claude Code learns from corrections. Moreover, future suggestions will align better with your standards. Additionally, this reinforces your conventions over time.
Reference CLAUDE.md when onboarding developers. Furthermore, tell new team members to read CLAUDE.md before starting. Moreover, it explains your conventions without needing lengthy meetings. Additionally, Claude Code teaches them your standards through its own behavior.
For large language model development services, effective CLAUDE.md files are foundational to enterprise AI workflows. Furthermore, they reduce hallucinations and errors in AI-generated code. Moreover, they ensure consistency across teams and projects.
Sub-agents are specialized instances of Claude Code designed for specific tasks. Furthermore, they can work in parallel on different components. Moreover, they can be optimized for specific types of work. Additionally, they enable sophisticated task delegation.
Think of sub-agents as team members. Furthermore, you assign specific responsibilities to each agent. Moreover, they work independently but coordinate with other agents. Additionally, this parallel approach accelerates development significantly.
Common sub-agent types include:
Sub-agents are configured through the .claude/agents.json file. Furthermore, you define what each agent does. Moreover, you specify which MCP servers each agent accesses. Additionally, you define coordination rules.
Here is a basic sub-agents configuration:
{
“agents”: [
{
“name”: “feature-writer”,
“role”: “Feature development”,
“instructions”: “Write new features following CLAUDE.md standards. Focus on code quality and testability.”,
“mcp_servers”: [“github”, “filesystem”],
“parallelism”: 2
},
{
“name”: “test-writer”,
“role”: “Test automation”,
“instructions”: “Write comprehensive tests for new code. Aim for 90%+ coverage. Use Jest and Cypress.”,
“mcp_servers”: [“filesystem”],
“triggers”: [“after:feature-writer”]
},
{
“name”: “documentation”,
“role”: “Documentation generation”,
“instructions”: “Generate API documentation, README updates, and code comments. Keep documentation in sync with code.”,
“mcp_servers”: [“filesystem”],
“triggers”: [“after:feature-writer”]
}
]
}
This configuration creates three specialized agents:
The feature-writer agent focuses on code generation. Furthermore, it has access to GitHub and the file system. Moreover, it can run in parallel with other agents. Additionally, it prioritizes code quality and testing.
The test-writer agent focuses on testing. Furthermore, it triggers automatically after the feature-writer completes. Moreover, it writes comprehensive tests. Additionally, it ensures coverage targets are met.
The documentation agent generates documentation. Furthermore, it triggers after feature-writer completes. Moreover, it keeps documentation synchronized with code. Additionally, it reduces manual documentation burden.
Sub-agents work best when you define clear workflows. Furthermore, start with a high-level task. Moreover, sub-agents break it into specialized subtasks. Additionally, each sub-agent completes its portion in parallel.
Here is how a typical feature development workflow flows:
First, you describe the feature to the main Claude Code instance. Furthermore, it creates a feature specification. Moreover, it delegates to the feature-writer agent. Additionally, it schedules downstream tasks.
Second, the feature-writer agent creates the implementation. Furthermore, it follows CLAUDE.md standards. Moreover, it completes the implementation and commits it to a branch. Additionally, it notifies the test-writer agent.
Third, the test-writer agent creates comprehensive tests. Furthermore, it runs the entire test suite. Moreover, it reports coverage metrics. Additionally, it ensures all tests pass.
Fourth, the documentation agent updates relevant documentation. Furthermore, it generates API documentation from code comments. Moreover, it updates README files. Additionally, it creates migration guides if needed.
Finally, the review agent checks everything. Furthermore, it verifies code quality and coverage. Moreover, it checks for security issues. Additionally, it approves or requests changes.
Coordination is critical when using multiple agents. Furthermore, agents need to know what others are doing. Moreover, they need to avoid conflicting changes. Additionally, they need to sequence work properly.
Use explicit dependencies in your agent configuration. Furthermore, specify which agents run after others complete. Moreover, define what happens if an agent fails. Additionally, create rollback procedures for failed agents.
Use git branches to isolate agent work. Furthermore, each agent works on its own branch. Moreover, final coordination merges branches in sequence. Additionally, this prevents conflicts and enables rollback.
Implement approval gates between critical steps. Furthermore, automated testing might not catch all issues. Moreover, human review catches problems agents miss. Additionally, approval gates prevent bad code from reaching production.
Imagine building a new customer API endpoint. Furthermore, here is how sub-agents divide the work:
Feature-writer agent: Creates the endpoint handler, database queries, and business logic. Furthermore, it implements according to your API design standards. Moreover, it takes 1-2 hours.
Test-writer agent: Creates unit tests for the handler and queries. Furthermore, it creates integration tests for the full endpoint. Moreover, it creates stress tests for high-volume scenarios. Additionally, it runs the full test suite. Furthermore, this takes 1-2 hours in parallel with feature-writer.
Documentation agent: Generates OpenAPI documentation for the new endpoint. Furthermore, it creates usage examples. Moreover, it updates the API guide. Additionally, this takes 30 minutes in parallel.
Review agent: Checks code quality, security, and architecture. Furthermore, it verifies test coverage exceeds 90%. Moreover, it confirms documentation is accurate. Additionally, this takes 15 minutes.
Total time: 2-2.5 hours instead of 8-10 hours if done sequentially by a single developer.
Start small and iterate. Furthermore, do not try to automate everything immediately. Moreover, begin with one or two simple workflows. Additionally, expand gradually as you learn what works.
Monitor Claude Code performance. Furthermore, track how much time it saves. Moreover, measure code quality metrics. Additionally, adjust configuration based on results.
Review all Claude Code output carefully. Furthermore, AI makes mistakes. Moreover, human oversight is essential. Additionally, especially review security-sensitive code.
Use version control for CLAUDE.md and agent configurations. Furthermore, track changes over time. Moreover, this enables easy rollback. Additionally, it helps teams understand evolution of standards.
Establish code review processes. Furthermore, Claude Code is a tool, not a replacement for review. Moreover, have human developers review important code. Additionally, use code review to catch issues Claude Code missed.
Do not rely on Claude Code 100%. Furthermore, it is a productivity tool, not a replacement for developers. Moreover, human judgment remains essential. Additionally, over-reliance on AI creates quality issues.
Do not use generic CLAUDE.md files. Furthermore, generic instructions produce generic code. Moreover, your context is unique. Additionally, invest time in specific, detailed CLAUDE.md files.
Do not enable all MCP servers. Furthermore, unused servers add complexity and security risk. Moreover, each server increases startup time. Additionally, focus on servers that provide real value.
Do not skip security review. Furthermore, Claude Code sometimes produces insecure code. Moreover, specifically review authentication, authorization, and data handling. Additionally, follow security best practices religently.
Do not forget about documentation. Furthermore, Claude Code can generate documentation automatically. Moreover, automated documentation is still imperfect. Additionally, review and improve it.
Use this checklist before deploying Claude Code workflows to production:
Setup and Configuration
Code Quality
Monitoring and Observability
Team and Documentation
Security
| Feature | Claude Code | GitHub Copilot | Cursor | Windsurf |
|---|---|---|---|---|
| Understanding of Codebase | Excellent (full context access) | Good (limited to current file) | Excellent (deep integration) | Very Good (modern architecture) |
| Configuration Options | Excellent (MCP, CLAUDE.md) | Limited (settings.json) | Good (cursor rules) | Good (configuration files) |
| Sub-Agent Support | Yes (advanced) | No | Limited | No |
| MCP Server Integration | Native support | No | No | No |
| CLAUDE.md Support | Yes (central to workflow) | No | No | No |
| Multi-Project Support | Excellent | Good | Good | Good |
| Enterprise Security | Excellent (customizable) | Good (GitHub-managed) | Good | Good |
| Cost | Reasonable (usage-based) | Moderate (subscription) | Moderate (subscription) | Moderate (subscription) |
| Learning Curve | Moderate (more features) | Gentle | Gentle | Gentle |
| Production Readiness | Excellent | Good | Excellent | Very Good |
| Customization Level | Very High | Moderate | High | Moderate |
Comparison of Claude Code, GitHub Copilot, Cursor, and Windsurf across code understanding, customization, enterprise readiness, security, and developer productivity.
Claude Code becomes powerful when you configure it properly. Furthermore, basic setup leaves most capabilities unused. Moreover, production setup requires MCP servers, CLAUDE.md files, and sub-agents. Additionally, the investment pays enormous dividends.
MCP servers connect Claude Code to your tools and systems. Furthermore, proper configuration keeps Claude Code focused. Moreover, limited servers reduce complexity. Additionally, security improves with careful server selection.
CLAUDE.md files eliminate repetitive instruction-giving. Furthermore, they standardize code across your team. Moreover, they reduce hallucinations and errors. Additionally, they make onboarding faster.
Sub-agents enable parallel task execution. Furthermore, specialized agents produce better results. Moreover, coordinated workflows accelerate development. Additionally, this is where Claude Code becomes truly powerful.
Production readiness requires monitoring and oversight. Furthermore, Claude Code is a tool, not a replacement for developers. Moreover, human review remains essential. Additionally, careful process implementation ensures success.
Claude Code setup for real projects is not complicated. Furthermore, it requires thoughtful configuration. Moreover, the effort investment is modest compared to payoff. Additionally, you gain access to genuinely transformative capabilities.
Start with basic Claude Code installation. Furthermore, set up essential MCP servers for your workflow. Moreover, create a detailed CLAUDE.md file. Additionally, implement simple sub-agents for common tasks.
Monitor results and iterate. Furthermore, adjust configuration based on what works. Moreover, expand workflows as you gain confidence. Additionally, involve your whole team in the process.
Claude Code becomes your AI development partner when configured properly. Furthermore, it understands your codebase and preferences. Moreover, it produces code that matches your standards. Additionally, it accelerates development while maintaining quality.
For organizations implementing AI development services, proper Claude Code setup is foundational to enterprise AI strategy. Furthermore, your configuration determines your team’s productivity. Moreover, small upfront investment creates enormous long-term value.
The future of development is AI-assisted. Furthermore, Claude Code is one of the best tools available. Moreover, proper configuration unlocks its full potential. Additionally, you are ready to implement production-grade Claude Code workflows today.
Basic setup takes 1-2 hours. Furthermore, MCP configuration adds 2-4 hours. Moreover, CLAUDE.md file creation takes 1-2 hours. Additionally, sub-agent setup adds 2-3 hours. Total initial setup: 6-11 hours for a complete production configuration.
However, this is one-time investment. Furthermore, subsequent projects reuse most configuration. Moreover, teams reduce setup time on second and third projects. Additionally, the time pays for itself within first week of use.
Yes, absolutely. Furthermore, this is the recommended approach for teams. Moreover, shared CLAUDE.md ensures consistency. Additionally, shared MCP configuration enables collaboration.
Store your .claude directory in version control. Furthermore, all developers pull the same configuration. Moreover, everyone works with identical settings. Additionally, this prevents configuration drift.
Yes, when configured properly. Furthermore, MCP servers isolate data access. Moreover, sensitive tokens stay in environment variables. Additionally, you control exactly what Claude Code can access.
However, you must review Claude Code output. Furthermore, AI makes mistakes including security mistakes. Moreover, security-sensitive code needs human review. Additionally, follow your organization’s security practices regardless.
Implement comprehensive testing first. Furthermore, Claude Code errors caught by tests do not reach production. Moreover, adequate test coverage is your primary defense. Additionally, human code review is your second defense.
If errors reach production, revert immediately. Furthermore, investigate what Claude Code did wrong. Moreover, update CLAUDE.md to prevent similar errors. Additionally, adjust your configuration based on lessons learned.
