Arpan Patel published a comprehensive guide to Claude Code on his blog — a tool that is changing the way developers work. This is not another “how to write a prompt” tutorial, but rather a collection of practical configuration techniques and workflow patterns.
TL;DR: Arpan Patel prepared a guide called “Beyond the Prompt: Claude Code” describing the configuration of the
.claudedirectory,CLAUDE.mdfiles, the Skills system, subagents, plugins, and the/goaland/insightscommands. The material includes workflow patterns used by the Anthropic team, as well as practical examples of integration with MCP and code editors.
What 7 Claude Code Techniques Does Arpan Patel Describe?
Arpan Patel’s guide focuses on configuring the work environment to better leverage Claude Code’s capabilities. Patel describes specific mechanisms — from the structure of the .claude directory, through configuration files, to advanced workflow patterns. The material is based on the experiences of Claude Code’s creators gathered in interviews and Anthropic documentation.
The first technique is proper organization of the .claude directory, which stores all of the tool’s configuration files. The second involves creating a CLAUDE.md file following the pattern used by Boris Cherny — the creator of Claude Code. The third technique is using CLAUDE.local.md to store configuration specific to the local environment.
Subsequent techniques cover the Skills system with examples, creating custom subagents, plugin integration, and leveraging less commonly used commands such as /goal and /insights. Patel also describes workflow patterns that the Anthropic team uses on a daily basis.
What Is the .claude Directory and How to Configure It?
The .claude directory is the central location for storing Claude Code configuration in a project. It contains files that define the tool’s behavior, coding preferences, and instructions specific to a given repository. This structure enables consistent configuration across the entire team.
Inside the directory, you will find files such as CLAUDE.md (the main configuration file), CLAUDE.local.md (local configuration, not committed to the repository), and Skills and subagent definitions. Additionally, the directory may contain MCP (Model Context Protocol) files defining integrations with external tools.
Configuring the .claude directory requires understanding the file hierarchy and their purposes. For example, CLAUDE.md should contain general project rules, while CLAUDE.local.md should hold developer preferences such as formatting style or favorite libraries.
It is worth reviewing the directory structure before starting work on a new project. This makes it easier to add rules and modify Claude Code behavior later without having to change the code.
How to Write CLAUDE.md Following Boris Cherny’s Pattern?
Boris Cherny — the creator of Claude Code — in an interview with Platformer discusses his approach to configuring the tool. His CLAUDE.md pattern is based on clear, concise instructions that guide the model’s behavior without unnecessarily expanding context.
The CLAUDE.md file should contain sections defining: the project’s tech stack, naming conventions, preferred architectural patterns, and testing rules. Cherny recommends avoiding generalities — instead of “write clean code,” write “use TypeScript strict mode, avoid any, prefer composables over mixins.”
File structure according to Cherny:
- Tech stack — specific versions of frameworks and libraries
- Code conventions — formatting, linting, and naming rules
- Architecture — design patterns, directory structure
- Testing — frameworks, coverage, preferred approach
- Forbidden practices — project-specific anti-patterns
- Dependencies — which packages to use, which to avoid
- Workflow — review process, branching, CI/CD
- Business context — domain, industry specifics
What Is CLAUDE.local.md For?
The CLAUDE.local.md file stores configuration specific to a developer’s local environment. It is not committed to the repository — it is listed in .gitignore. It allows each team member to customize Claude Code to their own preferences without affecting the team configuration.
Typical contents of CLAUDE.local.md include: paths to local tools, editor preferences, aliases used in a given environment, and temporary experimental instructions. Patel emphasizes that this file is the ideal place for iteratively testing new instructions before moving them to the main CLAUDE.md.
This pattern is particularly useful in teams where developers work on different operating systems or with different tools. For example, one team member may use macOS with Homebrew, while another works on Ubuntu with apt — CLAUDE.local.md allows accounting for these differences.
A similar approach to local configuration is described in the documentation on the gikiewicz.eu blog, where you will find an overview of Claude Code features.
What Are Skills in Claude Code and How to Create Them?
Skills are a Claude Code mechanism for defining reusable instruction sequences. They work similarly to functions in programming — they accept parameters, execute specific logic, and return a result. Patel describes them as “recipes” for repeatable development tasks.
Each Skill consists of a name, description, parameters, and a sequence of steps to execute. For example, a “create-api-endpoint” Skill could accept parameters: resource name, HTTP method, database schema — and then generate complete endpoints with validation, tests, and documentation.
Skill examples described by Patel:
- generate-crud — creating full CRUD for a resource
- write-migration — generating a database migration
- add-test-suite — adding a test suite for a module
- refactor-component — refactoring a component while preserving behavior
- create-docs — generating API documentation
- setup-ci — configuring a CI/CD pipeline
- lint-fix — automatically fixing linting issues
- security-audit — scanning code for vulnerabilities
Creating Skills requires defining clear boundaries of responsibility. A good Skill does one thing well rather than many things averagely. Patel recommends testing Skills across different scenarios before adding them to a project.
It is worth comparing this approach with Claude Code /ultraplan, where you will find information about task planning with Claude Code.
How to Create Custom Subagents in Claude Code?
Subagents are specialized instances of Claude Code that execute specific tasks within a main workflow. Arpan Patel describes their architecture — each subagent receives its own instruction context, separate from the main CLAUDE.md. This enables building multi-agent systems where one agent writes code, another conducts review, and yet another generates tests.
Patel emphasizes that subagents work well in scenarios requiring separation of responsibilities. For example, a “security-reviewer” agent can analyze code for vulnerabilities without having access to the “feature-developer” agent’s instructions. This prevents context conflicts.
In practice, subagents are configured in the .claude/subagents/ directory. Each subagent has its own definition file with instructions, allowed tools, and constraints. Patel recommends that each subagent have a single responsibility.
Subagent configurations according to Patel:
- feature-dev — creating new features
- test-writer — generating unit and integration tests
- code-reviewer — reviewing code for quality
- security-scanner — finding vulnerabilities in code
- docs-generator — creating technical documentation
- refactor-agent — refactoring while preserving behavior
- migration-helper — database migration assistant
- debugging-assistant — help diagnosing errors
Managing subagents requires accounting for token costs. Each subagent launches a separate session, which increases API usage. Patel recommends monitoring usage through the /costs command.
What Plugins Extend Claude Code’s Capabilities?
Anthropic published a security-guidance plugin for Claude Code that detects 25 dangerous code patterns in real time (Crypto Briefing, 2025). This is an example of a plugin that operates directly in the terminal, flagging vulnerabilities before they reach the repository. Patel describes this plugin as one of the most important elements of the Claude Code ecosystem.
Plugins are installed through the .claude/plugins/ directory. Each plugin can modify Claude Code’s behavior — from adding new commands, through integration with external services, to modifying the model’s responses.
Anthropic is developing plugins as an extension layer that does not require modifying Claude Code’s code. External developers can create their own plugins, similar to the VS Code ecosystem.
Plugin examples described by Patel:
- security-guidance — real-time scanning of 25 vulnerability patterns
- linter-integration — connecting Claude Code with ESLint/Prettier configuration
- git-hooks — automating commits and pre-push checks
- database-helper — SQL query assistant with schema validation
Installing a plugin involves adding its configuration to the .claude/plugins/ directory and restarting the session. Some plugins require additional dependencies.
More about Claude Code updates can be found in the Changelog — Claude Code Documentation.
What Are the /goal and /insights Commands?
The /goal and /insights commands are rarely used Claude Code features that Patel describes as “hidden superpowers.” The /goal command lets you define a session goal — for example, “implement OAuth2 authorization” — and Claude Code stays focused on that goal throughout the conversation, avoiding digressions.
Meanwhile, /insights generates a summary of what Claude Code has learned about the project during the session. This is useful for long conversations where the model accumulates context about architecture, dependencies, and code patterns. Insights can be exported to CLAUDE.md.
Patel recommends using /goal at the beginning of every work session. This reduces the time needed to achieve a result because the model does not waste context on irrelevant tasks. The /insights command works best at the end of a session.
Example use cases for the commands:
/goal implement-user-auth— a session focused on authorization/goal fix-memory-leak— diagnosing and fixing memory leaks/goal add-payment-webhook— payment system integration/insights— exporting knowledge about the project
These commands are available by default, but many users are unaware of them. Patel believes /goal should be a standard in every workflow.
How Does MCP Integrate Claude Code with External Tools?
Model Context Protocol (MCP) is a protocol connecting Claude Code with external tools — databases, APIs, file systems. Patel describes MCP as a communication layer that allows the model to read documentation, query databases, and call endpoints without leaving the terminal.
Configuring MCP requires adding an mcp.json file to the .claude/ directory. The file defines available MCP servers, their connection parameters, and allowed operations. Patel provides examples of integration with PostgreSQL, GitHub API, and the file system.
MCP extends Claude Code’s capabilities beyond code generation. Through it, the model can check CI/CD status, read production logs, and even manage tickets in Jira. Patel calls this “context without boundaries.”
MCP integration examples from the guide:
- PostgreSQL — querying the database and analyzing the schema
- GitHub — managing PRs, issues, and reviews
- Filesystem — reading and writing files outside the project
- Slack — sending task status notifications
- Jira — creating and updating tickets
- Docker — managing local containers
- Redis — inspecting cache and sessions
- AWS S3 — reading and writing objects
More about terminal integrations can be found in Claude Code Companion: How to Control Claude Code from Telegram?.
What Workflow Patterns Does the Anthropic Team Use?
The Anthropic team uses workflow patterns described by Boris Cherny in an interview with Platformer. Cherny describes a “plan-execute-verify” approach, where Claude Code first plans changes, then implements them, and finally verifies the results through tests.
Patel adds that the Anthropic team uses Claude Code in an iterative cycle. Each code change goes through a planning phase with the /goal command, execution with subagents, and verification with the security-guidance plugin. This cycle repeats until the goal is achieved.
Cherny advises 22-year-old computer science graduates to start startups, calling the current era a “golden age” (Business Insider, 2025). This indicates that Claude Code is designed with small, agile teams in mind.
Anthropic workflow patterns:
- Plan-execute-verify — the main Claude Code work cycle
- Goal-first — every session starts with
/goal - Subagent delegation — delegating tasks to specialized agents
- Continuous security — scanning for vulnerabilities after every change
- Insight harvesting — saving knowledge from sessions through
/insights
Workflow approach comparison:
| Pattern | When to Use | Tool |
|---|---|---|
| Plan-execute-verify | Every feature | /goal + subagents |
| Security-first | Production projects | security-guidance plugin |
| Insight-driven | Long projects | /insights + CLAUDE.md |
| Subagent delegation | Complex tasks | .claude/subagents/ directory |
| MCP-integrated | Working with external systems | mcp.json |
More about task planning with Claude Code can be found in Claude Code /ultraplan.
Frequently Asked Questions
How much does using Claude Code with subagents cost?
Each subagent launches a separate API session, meaning token usage grows proportionally to the number of active subagents — Patel recommends monitoring costs through the /costs command and limiting to 2-3 subagents per session.
Does the security-guidance plugin replace a security audit?
The security-guidance plugin detects 25 dangerous code patterns in real time (Crypto Briefing, 2025), but does not replace a full audit — it serves as a protective layer during development, not a compliance tool.
How often should the CLAUDE.md file be updated?
The CLAUDE.md file should be updated with every change to the project’s architecture or tech stack — Patel recommends adding new rules after each session using /insights to accumulate knowledge iteratively.
Does MCP require additional infrastructure?
MCP requires running intermediary servers for each integrated tool — configuring PostgreSQL MCP involves adding a connection string to mcp.json, while GitHub MCP requires an access token with appropriate permissions.
Summary
Arpan Patel’s guide shows that effectively using Claude Code goes beyond writing prompts. The key elements are configuring the .claude directory, CLAUDE.md and CLAUDE.local.md files, the Skills system, subagents, plugins, /goal and /insights commands, MCP integrations, and the Anthropic team’s workflow patterns.
Key takeaways:
- The
.claudedirectory is the central configuration location — organize it according to Boris Cherny’s pattern - The
CLAUDE.mdfile should contain specific instructions, without generalities - Skills and subagents allow automating repeatable development tasks
- The security-guidance plugin detects 25 vulnerability patterns in real time
- The
/goaland/insightscommands are rarely used features that significantly accelerate work
You can find Patel’s full guide on his blog. More Claude Code materials are published on gikiewicz.eu — where you will find feature overviews, comparisons with alternatives, and practical configuration guides.