Claude Code: Everything You Need to Be Dangerous

Claude Code has genuinely reshaped how I use AI as a real engineering partner in my daily workflow.

It's not Copilot. It's not Cursor. It has no GUI. It's 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 really is comes down to, IMHO, knowing how to direct it correctly.

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

This article compiles everything I wish I'd known from day one.

Benefits

The Terminal: Your Familiar Ground

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're a Vim, VSCode, or IntelliJ person - the terminal is the common denominator for all developers. Claude works with your current setup, not against it.

No Middlemen

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

While Cursor, Copilot, and others build on external APIs—adding layers, latency, and margins—you access directly from the source. 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's not aggressive autocomplete that turns you into a spectator of your own code. It's 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's hard to explain until you try it, but there's an enormous difference between feeling like you're programming with a tool versus feeling like the tool is programming for you.

Initial Setup

CLAUDE.md: The Shared Brain with Your Agent

Claude Code automatically looks for CLAUDE.md files when starting. It's 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 Claude Code project, what's important is dedicating time to document for real: half an hour, three quarters, or whatever you need. It seems like a waste of time, but you're actually saving it.

That extra time should help you:

• 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 technology stack explicitly.

This way, your CLAUDE.md doesn't 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 behind 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 at 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 the instructions across all your sessions. Claude combines them intelligently. Use CLAUDE.local.md for configuration that doesn't go to git (tokens, local paths).

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

Permission Management

A recurring complaint about Claude Code is 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 Claude Code.

You can do it gradually, while working, or modify the configuration so 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).

Invoke Claude from GitHub

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

Once authentication is complete (gh auth login), the App installation, and adding the workflow to the repository, you have access to two main flows:

1. Conversational review: tag @claude in any pull request or issue to get responses, explanations, or improvement suggestions directly in the thread. Claude doesn't just answer: it reasons, explains, and proposes structured changes.
2. Automatic CI/CD review: configure a workflow for Claude to automatically review each PR as part of your pipeline. Ideal for detecting code smells, inconsistencies, or style violations before it goes 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.

Patterns That Increase Adherence

Your Inherited Bash Environment

Claude Code inherits your complete 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's 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" each time, it already knows exactly how you want to use that tool. It's the difference between letting Claude explore vs. giving it a clear operations manual.

Both work, but one is much faster and predictable (and also saves you some tokens).

Claude Code Inherits Your Terminal

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

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

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

## 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 speeds up its response time. Instead of depending 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 like another developer on the team. More speed, less friction, fewer tokens wasted.

MCP: Connect Claude with External Services

I've 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're not simple HTTP calls (it's not an API), they're 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 in 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've 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 their steps in chronological order, you can have some certainty when predicting the result.

Also, remember: we're not talking about an inert command, but an AI agent prepared to improvise and respond. This allows you to be more lax when preparing the command, because you know 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.

Also remember that to make commands more versatile you have access to the $ARGUMENTS variable that captures everything you pass after the command.

My Preferred 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 launching Claude straight into writing code. Why? Because between the model's eagerness 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.

Explore

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

At this point it helps a lot if you've created your CLAUDE.md file, as we saw before. If you've 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's not a static artifact: you can and should keep updating it with the new discoveries the agent makes during exploration.

This is where Claude's planning mode comes into play (which we'll see later), which is designed for guided exploration of the codebase. Through it, you can refine and enrich your CLAUDE.md with the 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 part 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 do that works wonderfully is giving the model a cue to ask any questions after reviewing the codebase.

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

Plan

Once the agent has the necessary context, it's 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's a very extensive, legacy codebase with readability problems (90% of code in production), giving your own indications to the model can help in the first iterations.

If you share your own plan, just like in the previous phase, it's very useful to ask Claude to challenge your proposal. This way you avoid biases and ensure better solutions.

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

Key: the more details and examples, the better. It's never enough. Investing extra time now will save you plenty later.

Execute

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

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

Your role should 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'll have results that you must validate.

Later you can allow continuous editing operations with "Always allow", but in the first iterations it's better to review each artifact in detail to correct course as soon as possible.

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

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

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 continue without understanding, you're giving up control and becoming dependent on a third party (in this case, an AI model).

Preserve

Finally, and since the agent has kept control of all commits created in the process, you can go one step further and ask it to create the pull request.

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've worked with Claude before you know exactly what I mean.

Key: in this type of operations, Claude tends to be extremely "verbose". If you don't constrain it with a clear instruction, it's possible it will add hundreds (or thousands) of words detailing each change, guaranteeing that no reviewer will want to process your PR.

Other Workflows

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.

1. Drag and drop a screenshot with the final design you want to achieve.

   • Pro-tip: if you're on MacOS, you can copy and paste the image.

2. Ask Claude to examine the design and ask the necessary questions until being sure that "you're both seeing the same thing".

   Check the design attached and explain in clear terms what you see.
   

3. Now request Claude to implement the design using the stack you choose.

   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've specified technical and implementation details (like using Vue and Tailwind as JavaScript and CSS frameworks and BEM as 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 one 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.

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:

1. Execute the task once and finish.
2. Not open the interactive chat where you can continue talking.
3. 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 reference. Use it for massive migrations or mechanical refactoring.

Unix Mode

As you've 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 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 accelerating 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 depending 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 doesn't require prompt engineering or prior knowledge of the architecture. Just ask as you would in a daily or on Slack.

Claude doesn't 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 the 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 doesn't just understand Git. It analyzes the diff, previous commit messages, project structure, and team conventions. The result: descriptive commits, safe revert, and workflows that don't require archaeology.

But where it really shines is 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 doesn't just generate 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, frictionless flow: active branch, clear message, well-described PR, assigned reviewers, and applied changes, all from the terminal. No copy and paste, no context switching.

Claude removes operational noise so you can focus on the real impact of your decisions and not on Git's 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's designed so each conversation is contextualized by directory.

1. 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.
2. Specific configuration
   • You can have a CLAUDE.md per project.
   • .claude/settings.json files define settings and permissions at the local level.
   • Tools like MCP, external services, or scripts change between environments.
3. Evolving context
   • Conversation history includes modified files, recent commits, and decisions made.
   • A question like "What changed in the authentication flow since yesterday?" only makes sense if the project context is preserved.

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

Switch Modes on the Fly

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

1. 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.
2. "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.
3. "Plan only" mode
   • Claude doesn't modify anything: just 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 prevents 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 ordered 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 automatically stops if it needs additional input.

Practical advantages:

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

Usage strategy:

1. Group related but sufficiently independent tasks.
2. Review the status periodically (every 15–20 minutes).
3. Avoid overly long queues — from 5–6 tasks onward the result reliability may decrease.

This partly rivals subagents (which we'll talk about later), but is more oriented to linear and chained tasks within the same context. It's not something I've used intensively, but when I have 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 the flow and ensuring minimal consistency throughout the process.

Intelligent Temporal Navigation

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

1. Escape ESC (once):

   • Stops the current operation maintaining the conversation.
   • Interrupts long executions without losing the thread.
   • Useful when Claude goes off on tangents (drifting, hallucination, etc).

2. Double Escape 2x ESC (fast):

   • Activates edit mode for 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"
     

3. Up arrow ArrowUp:

   • Navigate 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

The official documentation recommends: "Please think about this problem thoroughly and in great detail" or "Consider multiple approaches and show your complete reasoning".

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

Use it for complex problems that require 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 iterate indefinitely.

Give Space to Your Context

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

Expand text area:

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

For long prompts:

• Write in your favorite editor.
• Copy and paste the complete 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 the tab key as auto-complete (tab-completion) to reference files.

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

I mean don't just add context with @, but auto-complete the path to each file using tab.

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 that later 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 the context state in the current session, use /context.

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

• /clear - Clean slate:
  • Deletes all previous conversation. Use it 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 the conversation maintaining relevant information.
    • Claude removes:
      • Failed code iterations.
      • Repetitive debug messages.
      • Explorations that led nowhere.
    • But maintains:
      • Important decisions.
      • Final code.
      • Updated project configuration.

Note, Claude automatically compacts 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 depending on manual copy/paste:

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

  # Make Claude 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 only a bfief introduction. If you want to see what subagents are, check my Claude Code subagents guide.

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

How They Work

• They're stateless: each invocation starts with a clean context and doesn't carry previous conversations.
• Execute tasks autonomously: they work without intermediate interaction until returning a final result.
• Return a single message with their conclusions.
• You can launch several in parallel to maximize performance and coverage.

When to Use Them

• Complex searches that require multiple attempts or approaches.
• Extensive research in large codebases.
• Exploring 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 fresh context, without contamination 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 simple idea: use them for independent verification, exploring alternatives, and deep analysis without compromising the main thread's focus.

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 comes back multiplied. It's like that old habit of copying and pasting from Stack Overflow without knowing what you were doing: sooner or later it explodes.

The key is different: you define the strategy, Claude handles the execution. You set the vision and limits, and let the agent plan and execute within that framework.

The method that works best for me is fragmenting absolutely everything. No matter how ambitious the goal: turn it into atomic changes, small ones, 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 true wonders, but also introduce layers of unnecessary complexity—it's happened to me many times. The only way to avoid it is to continuously validate, just as you would validate the work of a talented junior but still without solid judgment.

Conclusion

What many see as a deficiency—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. You're still the one making decisions, not a popup suggesting every line.

That same design makes Claude work as a unifying layer: it doesn't matter if you're 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's 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. Move slowly, validate each step, use it for what it really shines—processing enormous amounts of information and generating immediate hypotheses.

This isn't 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 automatically handles PRs, issues, and reviews.
• 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, maintain course. You're 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 contaminating main context.
• Specificity = productivity: Vague prompts → useless code. Specific prompts → exact solutions.