Claude Code Professional Guide: Mastering the CLI for Senior Devs (2026) - Juan Andrés Núñez — Building at the intersection of Frontend, AI, and Humanism

Q: Is Claude Code free?

No, Claude Code works via the Anthropic API and you pay per token (usage). It is not included in the $17/month Claude Pro subscription.

It is no exaggeration to say that Claude Code has changed the way I use AI assistance in my work.

It is not Copilot. It is not Cursor. It has no GUI. It is an agent that works from your terminal with full access to your system.

The difference between using Claude Code as a "ChatGPT with file access" and leveraging it as the productivity multiplier it truly is, comes down to IMHO, knowing how to direct it correctly.

After several weeks of intensive use on "real" projects, I have discovered that the learning curve is steep - but the reward is proportional.

This article compiles everything I wish I had known from day one.

Claude Code vs Cursor and Copilot: Key Benefits

The terminal: your home turf

Claude Code lives where you already work. No new interface to learn, no extensions to install, no workflows to change. Terminal + your favorite editor. Period.

It doesn't matter if you are Vim, VSCode, or IntelliJ - the terminal is the common denominator for all developers. Claude works with your current setup, not against it.

No intermediaries

Anthropic builds both the engine and the car. They create Claude (the most used model for coding) and Claude Code (the best tool to leverage it).

While Cursor, Copilot, and others build on third-party APIs —adding layers, latency, and markups— you access the source directly. No middlemen. No markup. Maximum value for your money.

Assistance, not dependence

Subtle but crucial difference: Claude Code doesn't live glued to your editor suggesting every line. It gives you space to think.

It is not aggressive autocomplete that turns you into a spectator of your own code. It is a collaborator that appears when you need it and disappears when you don't. You maintain control of the architecture, critical decisions, the workflow.

It is complicated to explain until you try it, but there is an abysmal difference between feeling like you code with a tool versus feeling like the tool codes for you.

Installation and Advanced Configuration

`CLAUDE.md`: The shared brain with your agent

Claude Code automatically looks for CLAUDE.md files upon startup. It is your opportunity to program its behavior once instead of repeating the same instructions in every session.

A super simplified example (in the "real world" it deserves much more detail):

# Project: Vue 3 + TypeScript E-commerce

## Commands
- pnpm dev: Start Vite dev server (port 5173)
- pnpm test:unit: Run Vitest tests
- pnpm type-check: Run vue-tsc

## Code Standards
- ALWAYS use <script setup lang="ts">
- Pinia for global state, composables for logic
- Props: withDefaults() for complex defaults
- NEVER use @ts-ignore (use @ts-expect-error)

## Project Structure
- /composables: use* prefix (e.g., useAuth.ts)
- /stores: *Store suffix (e.g., cartStore.ts)
- /api: Typed API client modules

## Common Patterns
Always handle errors in composables:
const { data, error } = await useAsyncData('key', () => $api.get())
if (error.value) return handleError(error.value)

The snippet above is just a reduction to illustrate the idea. In a real project in Claude Code, the important thing is to dedicate time to document for real: half an hour, three quarters, or whatever you need. It seems like a waste of time, but you are actually gaining it.

That extra time should serve you to:

Think about the architecture you want and capture it.
Detail code conventions and standards.
Include external references, useful links, real snippets that someone can copy and execute.
Point out anti-patterns you want to avoid.
Define composition and tech stack explicitly.

In this way, your CLAUDE.md does not stay as a quick note, but becomes a living document that anyone on your team (or your future self) can consult to understand the why of each decision.

You can create the file (CLAUDE.md) manually or through the /init command. Claude will examine your project and generate an initial summary with all the context. You can also have multiple CLAUDE.md: one in the project root, others in subdirectories, all will be taken into account and processed.

You can even create one in your root directory (~/CLAUDE.md) with your global preferences and share instructions across all your sessions. Claude combines them intelligently. Use CLAUDE.local.md for configuration that does not go to git (tokens, local paths).

Additionally, you can press # during a session to add rules automatically.

Permission Management and Security

A recurring complaint about Claude Code is that it asks for permission for everything (especially for sensitive operations). Being a tool that has access to your command line, could it be any different?

What few know is that you can configure what permissions to grant to Claude Code.

You can do it gradually, while working, or modify the configuration so that Claude Code never asks you again.

Some examples:

Save a settings.json file that can be processed by your version control and shared with your team.

// .claude/settings.json (goes to git - team config)
{
  "allowedTools": [
    "Edit", // <- All edit operations
    "CreateFile",
    "Bash(pnpm test:*)", // <- Specific shell commands
    "Bash(git diff*)",
    "Bash(git commit*)"
    "WebFetch(domain:github*)" // Specific domains
  ]

Similarly, you can globally configure Claude Code permissions if you save the file in your home.

// ~/.claude.json (global - your machine)
{
  "neverAllow": ["Bash(rm -rf*)", "Bash(*sudo*)"],
  "domains": {
    "allowlist": ["vuejs.org", "vitejs.dev"]
  }
}

During a work session you can choose "Always allow" when validating a change (we'll talk about this later).
You can use the /permissions command to adjust all permissions (add and remove) on the fly.
For automation or experiments, claude --dangerously-skip-permissions disables everything (use it in Docker containers as they have no external connectivity).

GitHub Integration (CI/CD)

This will interest you: Claude can now integrate directly with your GitHub repositories via the /install-github-app command.

Once authentication (gh auth login), App installation, and workflow addition to the repository are completed, you have access to two main flows:

Conversational Review: tag @claude in any pull request or issue to get answers, explanations, or improvement suggestions directly in the thread. Claude not only answers: it reasons, explains, and proposes structured changes.
Automatic Review in CI/CD: configure a workflow for Claude to automatically review every PR as part of your pipeline. Ideal for detecting code smells, inconsistencies, or style violations before it passes to human review.

Since then, Claude has become a very effective first filter. On more than one occasion it has saved me from having to review an entire PR, pointing out only the critical points.

It's like having a tireless technical reviewer embedded in your development flow.

Productivity Patterns (Workflows)

Your inherited bash environment

Claude Code inherits your full terminal: aliases, functions, scripts, etc.

It can execute the --help flag of any tool to understand how to use it, but beyond standard commands, it is good practice to document your custom tools in CLAUDE.md, as we saw before.

## Custom Scripts
- ./scripts/reset-db.sh: Reset local database with seeds
- npm run studio: Open Prisma Studio on port 5555
- deploy-staging: Alias for deployment script

## Tool Versions
- Node 20.x required (uses .nvmrc)
- pnpm 8.x for package management

This way Claude doesn't have to "discover" every time, it knows exactly how you want it to use that tool. It is the difference between letting Claude explore vs. giving it a clear operations manual.

Both work, but one is much faster and predictable (and you also save a few tokens).

Claude Code inherits your terminal

One of the most powerful —and least commented— points of Claude Code is its ability to work within your real bash environment. This includes aliases, functions, custom scripts, and specific configurations of your stack.

Claude can execute --help on any command, but outside of standard binaries, it is good practice to document your internal tools in a file like CLAUDE.md. Real example:

## Custom Scripts
- ./scripts/reset-db.sh: Reset local database with seeds
- npm run studio: Open Prisma Studio on port 5555
- deploy-staging: Alias for deployment script

## Tooling
- Node 20.x (via .nvmrc)
- pnpm 8.x as package manager

This file acts as an operations manual: it prevents Claude from having to infer how your tools work and accelerates its response time. Instead of relying on context crawling, you give it a clear blueprint of your environment.

The difference? With explicit documentation, Claude goes from intuiting your flow to operating as one more developer on the team. More speed, less friction, fewer wasted tokens.

MCP: Connecting with External Services

Update Oct. 2025: Published a complete guide on how to create a code-review system with Claude Code and Playwright/Notion MCPs.

I have already talked about what MCP is and the possibilities it opens, but to summarize Model Context Protocol allows Claude to communicate with specialized services. They are not simple HTTP calls (it is not an API), they are tools with well-defined interfaces.

// .mcp.json (project config)
{
  "servers": {
    "puppeteer": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
    },
    "database": {
      "command": "mcp-server-postgres",
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      }
    }
  }
}

With MCP client (and server, if you wish), Claude Code can take screenshots of your app, execute database queries, or interact with external APIs.

The real power appears when combining multiple servers, for example: screenshot → detect visual error → search logs → create issue, but this is just the tip of the iceberg.

Custom Slash Commands

This is one of my favorite options and, again, I have already talked about it.

Slash commands are like reusable macros that define the steps to perform a task. Think of them as a recipe, where if you perform all its steps in chronological order, you can have some certainty when predicting the result.

Also, remember: we are not talking about an inert command, but an AI agent prepared to improvise and respond. This allows you to be looser when preparing the command, because you know that Claude can adapt to any unforeseen event.

To create a command, create a Markdown file in .claude/commands/ and, if you want, add tracking in your version control so the whole team can use them.

<!-- .claude/commands/vue-component.md -->
Create a new Vue component with this structure:

1. Generate component file: src/components/$ARGUMENTS.vue
2. Create test file: src/components/__tests__/$ARGUMENTS.spec.ts
3. Add Storybook story if applicable
4. Register in components index

Use TypeScript, setup syntax, and follow our patterns described in ./CLAUDE.md

Now /project:vue-component UserCard generates all the boilerplate. You can create commands for any repetitive flow.

Remember also, that to make commands more versatile you have access to the $ARGUMENTS variable that captures everything you pass after the command.

The Ultimate Workflow: Explore → Plan → Execute → Preserve

This is the workflow I use the vast majority of the time, and one of the most recommended by Anthropic itself.

One of the most common mistakes is to launch Claude straight to writing code. Why? Because between the model's desire to be useful as soon as possible and your own lack of planning, progress is likely to be slow and chaotic, with many iterations.

This flow avoids redoing work, but forces you to approach methodically. It forces you to think before acting.

1. Explore

First, you must let Claude explore the codebase it needs to act on.

At this point it helps a lot if you have created your CLAUDE.md file, as we saw before. If you have done your job well, that file should already contain the architecture, conventions, and patterns you want to follow. The important thing is to understand that it is not a static artifact: you can and should update it with new discoveries made by the agent during exploration.

Here comes Claude's planning mode (which we will see later), which is designed for guided exploration of the codebase. Through it, you can refine and enrich your CLAUDE.md with findings.

Personally, I usually use Opus mode to plan and Sonnet mode to execute (you can configure it with the /model command), (which allows me to clearly separate the strategic phase from the operational phase. The best thing is that, if your CLAUDE.md file already includes your plan, you can even delete the context or start a different agent and it will work just as well or even better, because everything is documented.

Example instruction:

Hey Claude, check the codebase, specially all auth-related files. Don't come with any crazy ideas yet, just understand the current implementation.

At this point we don't want to create any artifacts, just establishing the necessary context. You can also complement the context by adding references to files with @, dragging and dropping images (mockups, diagrams, Figma designs) or expanding the shared project context with #.

Something I also usually do and works wonderfully is giving the model a cue to ask any questions after reviewing the codebase.

Key: how to be sure you can advance to the next phase? Ask yourself: if Claude were a colleague, would they have the necessary information to start working?

2. Plan

Once the agent has the necessary context, it is time to indicate what you want to achieve.

You have two options: propose the implementation yourself, even superficially, or let Claude choose how to act.

Example:

Now, think about how to add OAuth without breaking existing login. Create a detailed plan.

In my experience, if it is a very extensive codebase, legacy, or with readability problems (90% of production code), giving your own directions to the model can help in the first iterations.

If you share your own plan, just like in the previous phase, it is very useful to ask Claude to challenge your proposal. This avoids biases and ensures better solutions.

Either way, you will see that Claude will create its own implementation plan, with a to-do list included. This is the time to ask for adjustments or challenge some points, because from here the execution begins.

Key: the more details and examples, the better. It is never enough. Investing extra time now will save it with interest later.

3. Execute

With the context defined and a clear plan, it is time to move to implementation. Here I want to be very clear: it is not like they sold it to you. This is not jazz.

You can't improvise “vibe coding” in a project that isn't a glorified CRUD.

Your role must be active, not passive.

Implement the plan step by step, running tests after each change (as atomic as possible), creating a commit.

After this instruction, Claude will start working and in a few seconds you will have results that you must validate.

Later you will be able to allow continuous editing operations with “Always allow”, but in the first iterations it is better to review each artifact in detail to correct the course as soon as possible.

As you progress, Claude should follow the agreed instructions, but keep in mind semantic drift: in iterative processes it is natural for the implementation to deviate from the initial goal.

In other words: don't get frustrated, the first version is almost never the definitive one.

Key: validate everything the model produces and, above all, understand each step. You don't have to write the code, but you do have to understand it. Every time you move forward without understanding, you are ceding control and becoming dependent on a third party (in this case, an AI model).

4. Preserve

Finally, and since the agent has tracked all commits created in the process, you can go a step further and ask it to create the change incorporation.

Lastly, create a Pull Request over `develop` branch. Please BE CONCISE stating the main takeaways (you can use Mermaid diagrams) of the changes and don't self promote.

As you can see, this last phase requires my explicit permission. Once again these countermeasures are necessary to curb the model's impetus. If you have worked with Claude before you know exactly what I mean.

Key: in this type of operation, Claude tends to be extremely “verbose”. If you don't bound it with a clear instruction, it is possible that it adds hundreds (or thousands) of words detailing every change, guaranteeing that no reviewer wants to process your PR.

Advanced Tricks (Tips & Tricks)

Iterative visual development

Although Claude Code has no GUI, you can —and should— attach external resources as context whenever possible.

An image is worth more than a thousand tokens.

In my experience, the difference between describing a design and showing it is abysmal.

Drag and drop a screenshot with the final design you want to achieve.
- Pro-tip: if you are on MacOS, you can copy and paste the image.
Ask Claude to examine the design and ask the necessary questions until sure that "you are both seeing the same thing".
```
Check the design attached and explain in clear terms what you see.
```

Now request Claude to implement the design using the stack of your choice.

Now I want you to code it, pixel perfect.
Ask for any extra clarification along the way.

Once again, if in your CLAUDE.md you have specified technical and implementation details (such as using Vue and Tailwind as JavaScript and CSS frameworks and BEM as a convention), this should be enough to start.

Now: control your expectations. Keep in mind that this process rarely returns the expected result on the first try and usually improves with each new iteration.

If you want to go a step further you can ask Claude to take screenshots —and then compare them with the produced artifact—using Puppeteer MCP server or iOS simulator MCP server for mobile, although I admit I have no experience with the latter.

Safe YOLO Mode

For mechanical tasks without risk (formatting, linting, type generation), you can give it total autonomy.

The -p (or --print) flag makes Claude Code:

Execute the task once and finish.
Not open the interactive chat where you can continue conversing.
Print the result and close the session.

# This will run in a Docker container without connectivity
 claude --dangerously-skip-permissions -p "Fix all ESLint errors in src/"
 claude --dangerously-skip-permissions -p "Fix TypeScript issues in components/*.tsx"

Anthropic provides Dev Containers configuration as a reference. Use it for massive migrations or mechanical refactoring.

Unix Mode

As you have seen, thanks to the -p flag Claude Code naturally integrates into the Unix philosophy of tools that can be customized and composed.

This makes it work perfectly with pipes, scripts, and automated workflows outside of its interactive mode.

# Pipe the output to other tools
claude -p "List all TODO comments" | grep -E "HIGH|CRITICAL"

# Use with find and xargs
find . -name "*.ts" | xargs claude -p "Add JSDoc to exported functions"

# Combine with git workflows  
git diff --name-only | xargs claude -p "Fix linting issues in these files"

# Even in scripts
#!/bin/bash
for component in src/components/*.vue; do
  claude -p "Add error boundaries to $component"
done

This ability to automate massive refactoring and complex fixes through Unix pipelines opens fascinating possibilities for development automation.

Faster Onboarding with Claude Code

One of the most powerful uses of Claude Code is speeding up onboarding to a new codebase. It works like having a Junior Frontend available 24/7, with full access to the project and contextual knowledge of business logic.

Examples of questions you can ask directly:

How does the authentication flow work?
Where is the cart state managed?
Why do we use this pattern in API calls?
What edge cases does the payment flow handle?
Show me examples of how other components handle loading states
What's the difference between UserService and AuthService?

Instead of relying on outdated documentation or manually reviewing the repository, Claude analyzes the real code, understands comments, reviews commit history, and provides precise answers with specific project references.

It does not require prompt engineering or prior knowledge of the architecture. Just ask as you would in a daily or on Slack.

Claude does not replace critical reading, but it does reduce the time needed to build a useful mental model of the system.

Git and GitHub, without leaving the terminal

Claude Code acts as a semantic layer (ORMish) over Git: it interprets your intentions, analyzes project context, and executes complex actions without you having to remember every flag or command.

Questions you can ask directly:

What changes made it into v2.3.0?
Who last modified the auth module and why?
Revert the last 3 commits but keep the changes staged
Cherry-pick the bugfix from main to production
Show me all commits that touched the payment flow this quarter
Create a hotfix branch from the last stable release

Claude not only understands Git. It analyzes the diff, previous commit messages, project structure, and team conventions. The result: descriptive commits, safe revert, and workflows that do not require archeology.

But where it really stands out is in handling GitHub through the official CLI. With gh installed, you can operate the entire collaboration cycle without leaving the terminal:

Create PR from current branch with a detailed description
Fix all review comments on PR #234
Triage open issues and suggest priorities
Check if there are similar closed issues before creating a new one
Draft release notes for all commits since v1.2.0
Find PRs that might have introduced this regression

Claude not only generates commands: it understands the purpose of each PR, analyzes the diff, reviews change history, summarizes previous conversations, and applies suggested changes directly.

The result is a continuous and frictionless flow: active branch, clear message, well-described PR, assigned reviewers, and changes applied, all from the terminal. No copy-paste, no context switching.

Claude eliminates operational noise so you can focus on the real impact of your decisions and not on the Git API.

How to get the most out of Claude Code

Resume exactly where you left off

Claude Code allows continuing a previous session using the --resume flag or the /resume command. This functionality is not trivial: it is designed so that each conversation is contextualized by directory.

Isolation by project
- Each folder represents a different codebase.
- Claude maintains separate conversations to avoid context contamination.
- Responses are based on the code and configuration available in that directory.
Specific configuration
- You can have a CLAUDE.md per project.
- .claude/settings.json files define settings and permissions locally.
- Tools like MCP, external services, or scripts change between environments.
Evolutionary context
- Conversation history includes modified files, recent commits, and decisions taken.
- A question like “What changed in the auth flow since yesterday?” only makes sense if project context is preserved.

Important: this functionality is local, it is not synchronized in the cloud. If you need to port it to another environment, you can use /export to transfer conversation history and its associated context.

Checkpointing: never lose a change again

Claude Code automatically tracks every change it makes to your code, creating checkpoints that allow you to go back at any time without losing anything.

How It Works

Automatic Tracking: Every prompt creates a new checkpoint before Claude edits code.
Persistence between sessions: Checkpoints survive closing and reopening conversations (cleaned up after 30 days).
No configuration: Works from the moment you start using Claude Code.

Activate Rewind Menu

Double escape (ESC + ESC, as we have seen) or the /rewind command open the temporary menu:

Three types of restoration:

Conversation only → Revert to a previous message but keep all code changes.
Code only → Revert files but keep conversation history.
Code + conversation → Restore both to a previous point.

Change mode on the fly

Claude Code allows toggling between three permission levels, adapting to the development moment you are in. You can change modes quickly with Shift + Tab.

Normal mode (no visible indicator)
- Standard flow with default confirmations.
- Claude requests authorization before modifying files or executing sensitive commands.
- Ideal for review, testing, or tasks with production impact.
- Example: Create PR and prepare for deployment.
“Accept edits” mode
- Claude can edit files directly without asking for confirmation.
- Speeds up repetitive tasks during active development.
- Still requires explicit permission to execute bash commands.
- Example: Implement all the auth improvements.
“Plan only” mode
- Claude modifies nothing: only analyzes, reads, and proposes changes.
- Perfect for auditing a codebase without touching a line.
- Example: Analyze the auth system and suggest improvements.

This distinction by modes avoids accidents, reduces friction, and allows you to work with an assistant that knows when to act and when to observe.

Queue system: Delegate and disconnect

Claude Code allows queuing multiple consecutive instructions and processes them in an orderly and contextual way:

"Add JSDoc comments to all functions"
"Also fix any TypeScript errors"
"And run the test suite when done"

It doesn't just execute tasks in sequence. It evaluates dependencies, preserves context between steps, and stops automatically if it needs additional input.

Practical advantages:

Efficient delegation: You can group related tasks and continue with other activities.
Continuous context: Each step is executed taking into account previous changes.
Intelligent control: Stops at ambiguities, errors, or decisions requiring intervention.

Usage strategy:

Group related but sufficiently independent tasks.
Check status periodically (every 15–20 minutes).
Avoid queues that are too long — starting from 5–6 tasks reliability may decrease.

This rivals in part with subagents (which we will talk about later), but is more oriented towards linear and chained tasks within the same context. It is not something I have used intensively, but when I have done so the result is acceptable.

Example:

"Refactor UserService to use async/await"
"Update all components that use UserService"
"Fix any resulting TypeScript errors"
"Run tests and fix any failures"
"Create commit with descriptive message"

Claude will execute each step, preserving flow and ensuring minimal consistency throughout the process.

Claude Code includes three ways to control navigation and course correction, without losing context. This temporal navigation is especially valuable in long sessions where you want to adjust instructions without starting from scratch.

Escape ESC (once):
- Stops the current operation while keeping the conversation.
- Interrupts long executions without losing the thread.
- Useful when Claude goes off on a tangent (drifting, hallucination, etc).

Double Escape 2x ESC (fast):

Activates edit mode of the previous message.
Editable field appears with your last prompt.
Modify and resend with all context preserved.

Practical use case:

Your prompt: "Refactor all components to use Composition API"
[Claude starts working]
[You realize you wanted only some components]
ESC ESC → Edit to: "Refactor only auth-related components to use Composition API"

Up Arrow ArrowUp:
- Navigates through previous prompts.
- Useful for repeating similar commands.

Activate deep thinking

Although not officially documented, the words think, think hard, think harder, and ultrathink activate different levels of reasoning.

Official documentation recommends: "Please think about this problem thoroughly and in great detail" o "Consider multiple approaches and show your complete reasoning”.

When Claude enters extended thinking mode you will see its "reasoning process" in light gray and italics.

Use it for complex problems requiring real analysis, not for mechanical tasks.

Specificity = productivity

Vague prompts generate useless code. Specific prompts generate exact solutions.

Abstract and confusing:

"add form validation"
"improve performance"
"fix the bug"

Effective and specific:

"add Zod validation to checkout form. Validate email, phone with Spanish format, and postal code. Show inline errors using our error component"
"add virtual scrolling to ProductList component when items > 100. Use @tanstack/vue-virtual"
"fix the null pointer exception in PaymentService.processRefund() when amount is undefined"

Include: specific technologies, concrete files, success criteria, and constraints.

Claude doesn't guess —specify or you iterate indefinitely.

Give space to your context

Claude Code's interface can feel tight for long prompts or pasting extensive code:

Expand text area:

Shift + Enter - Add new line without sending (if it doesn't work, launch /terminal-setup command).
Ctrl + J - Expands input area (universal).

For long prompts:

Write in your favorite editor.
Copy and paste the full prompt.
Or use files: "Read my-prompt.md and implement what it describes".

Especially useful for complex instructions, technical specifications, or when you need to format code within the prompt.

Mention specific files

Use tab tab for auto-completion (tab-completion) to reference files.

"Refactor <@>src/com<tab>ponents/CartItem.vue<enter> to use the new price formatting composable"

I mean not only adding context with @, but auto-completing the path to each file using the tabulator.

URLs for documentation

Claude accesses URLs in real time for updated documentation and examples:

Manual copy-paste:

"implement a date picker like the one I saw online"
[copies code from browser]

Direct reference:

"Implement the date picker following https://vuejs.org/examples/#date-picker"
"Use the pattern described in https://antfu.me/posts/composable-vue-vueday-2021"
"Follow the Tailwind component structure from https://tailwindui.com/components/forms/input-groups"

Permission optimization: /permissions

Remember you can add rules like:

WebFetch(domain:vuejs.org) - Allow
WebFetch(domain:tailwindcss.com) - Allow

Configure frequent domains to avoid repetitive confirmations. Claude always accesses the most current version of the documentation.

Intelligent context management

Context is limited and degrades with irrelevant information. To see context status in current session, use /context.

Now, two main commands to keep it "clean":

/clear - Clean slate:
- Removes all previous conversation. Use between completely different tasks:
- Finished a feature → /clear → start another.
- Change project → /clear.
- Claude gets confused with obsolete context → /clear.
/compact - Intelligent compression:
- /compact condenses conversation keeping relevant information.
  - Claude removes:
    - Failed code iterations.
    - Repetitive debug messages.
    - Explorations that led nowhere.
  - But keeps:
    - Important decisions.
    - Final code.
    - Updated project configuration.

Note, Claude compacts automatically when context fills up, but doing it manually gives you control over the precise moment.

Data input beyond chat

We already saw the -p flag to exit interactive mode, but there are more ways to feed information to Claude without relying on manual copy/paste:

  # Pipe big logs
  cat error.log | claude -p "analyze these Vue errors"

  # Make Claue read files directly
  "Read ./test-results.json and identify flaky tests"

  # Fetch URLs (even localhost)
  "Analyze the performance profile at http://localhost:3000/__profiler"

These alternatives are especially valuable for large files, extensive logs, or when you want to automate analysis.

Instead of saturating the chat with thousands of lines, you let Claude access the source directly.

Subagents: The Force Multiplier

This is a brief introduction, if you want to see them in practice take a look at my Claude Code subagents guide.

Claude can create specialized versions of itself that work independently and in parallel. They are subagents, and they completely change the rules when you understand how to integrate them into your workflow.

How they work

They are stateless: each invocation starts with a clean context and does not drag previous conversations.
They execute tasks autonomously: they work without intermediate interaction until returning a final result.
They return a single message with their conclusions.
You can launch several in parallel to maximize performance and coverage.

When to use them

Complex searches requiring various attempts or approaches.
Extensive investigation in large codebases.
Exploration of multiple files or patterns in parallel.

"Before implementing auth, use subagents to:
1. Research our current session management
2. Analyze security implications
3. Check for existing auth utilities
Then synthesize findings into an implementation plan"

Subagents work with a fresh context, without pollution from the main conversation. It's like having a team of juniors researching while the senior maintains the global vision.

To get the most out of them, use explicit phrases in your instructions:

“Use subagents to verify…”,
“Have a subagent investigate…”,
“Ask subagents to explore alternatives…”.

Keep this idea: use them for independent verification, alternative exploration, and deep analysis without compromising the focus of the main thread.

Personal Experience

Working with Claude Code has taught me something that seems obvious, but is hard to apply: if you delegate without understanding, the error always returns multiplied. It's like that old habit of copy-pasting from Stack Overflow without knowing what you were doing: sooner or later it explodes.

The key is different: you define the strategy, Claude takes care of execution. You mark the vision and limits, and let the agent plan and execute within that frame.

The method that works best for me is fragmenting absolutely everything. No matter how ambitious the goal is: turn it into atomic, small changes, with commits after each step. This reduces risks and you always have a stable point to return to.

And a crucial reminder: never trust blindly. Claude can produce real wonders, but also introduce unnecessary complexity layers —it has happened to me many times. The only way to avoid it is continuous validation, just as you would validate the work of a talented junior but still without solid criteria.

Conclusion

What many see as a lack —that Claude Code doesn't live inside your IDE/editor— is actually its greatest virtue. Keeping it in the terminal gives you distance, perspective, and above all, prevents the assistant from ending up replacing your own judgment. It is still you who makes decisions, not a popup suggesting every line.

That same design makes Claude work as a unifying layer: it doesn't matter if you are frontend, backend, devops, ML engineer, or designer. Each with their stack, all with the same common ground: the terminal. There Claude adapts to your flow, instead of forcing you to adopt its own.

And no, Claude Code is not your replacement. It is your multiplier. Well used it can double or triple your impact: less friction, more focus, more speed. The condition is simple but demanding: common sense. Advance slowly, validate each step, use it for what it really shines at —processing huge amounts of information and generating immediate hypotheses.

This is not vibe coding. This is AI Augmentation: you think, you decide, Claude accelerates.

Main takeaways

CLAUDE.md is your shared brain: Configure it once, save repeating context in every session.
Granular permissions: Use /permissions and settings.json files to control exactly what Claude can do.
GitHub CLI = superpower: With gh installed, Claude manages PRs, issues, and reviews automatically.
Methodical workflow: Explore → Plan → Execute → Preserve. Never jump straight to code.
Context is gold: Use /clear between tasks, reference specific files, feed URLs directly.
Active control: Interrupt with Escape, correct early, stay on course. You are not a spectator.
Powerful Unix mode: -p flag to exit interactive mode and use alongside scripts, pipes, automation. Integrate Claude into any workflow.
MCP and slash commands: Extend capabilities with external tools and reusable macros.
Subagents for complex tasks: Delegate parallel research without polluting main context.
Specificity = productivity: Vague prompts → useless code. Specific prompts → exact solutions.

Cheat Sheet: Essential Commands

Save this table. It's everything you need 90% of the time.

Command	Action	When to use it
`/init`	Initialize project	Starting a new repo. Creates `CLAUDE.md`.
`/cost`	Show consumption	If worried about bill or token usage.
`/clear`	Clear context	Changing tasks to avoid hallucinations.
`/compact`	Summarize history	When session gets long and slow.
`/bug`	Report a bug	If Claude Code crashes (to Anthropic).
`/doctor`	Diagnosis	If you have permission or connection issues.
`/help`	Interactive help	When you forget any of these commands.

FAQ

Is Claude Code free? No, Claude Code works via Anthropic API and you pay per token (usage). It is not included in the $20'ish/month Claude Pro subscription.

Does it work on Windows? Yes, it works natively on Windows via PowerShell or WSL2 (recommended).

Which model does it use? It defaults to Claude 4.5 Sonnet, but you can switch to Opus (more powerful, more expensive) or Haiku (faster) with the /model command.