From AI Skeptic to Claude Junky: A Developer's Guide to Managing Your AI Team

As an engineering leader I observe two almost non-overlapping worlds:

• In one of them, AI agents have won and we don’t need developers anymore (in fact, we don’t need anyone except influencers with their posts about another tool killing another one)

• and in another, ChatGPT (we have only one LLM, right?) is always drunk Frankenstein who suggests only dumb shit and only good at rewriting corporate emails.

Initially, I belonged to the second camp for quite a while even though I tried Cursor a year ago before it became mainstream. I moved close to the first camp only when I tried Claude Code for extensive amount of time.

Why Claude Code

Regardless of organization, the majority of developers are opinionated, they don't like to be told what to use especially when it’s related to their tooling. That’s the exact reason, why such a simple thing like “a limited set of supported tooling in the company” is not trivial and requires exceptional Developer Experience team in the organization.

Because of it, I always prefer CLI tools, they are easy to integrate in any existing workflow. So I got hooked to Claude Code almost immediately, the only reason which stopped me from promoting it in the company was price. I created a PR within an hour, the PR was a fix for a small issue, which required changes in multiple repositories. It cost me $3, which was quite expensive even though the experience was amazing. So I postponed this idea for a while and was trying to make Cursor work according to my needs, failing in it again and again. Until Claude made Claude Code part of the Pro plan, which allowed me to use it with fixed rate of 100$ per month.

Saying that I got hooked would be an understatement, I was waiting for limits to be reset several times per day, so it took me only one week to give up and upgrade to x20 Pro plan. Now I am a Claude junky.

Here is my setup if you want to accompany me.

Mindset shift

Before jumping into specifics, it’s important to understand shift in work - you are no longer an executor, you are an orchestrator and responsible for results while you work through others. In a nutshell, you are a manager but a manager of an agent(s), not humans.

This is a key to efficient work with AI. Yes, you can deliver complex feature faster than AI, yes, you can do it without hallucinations. That's what most managers were capable of when they just switched their path to management. It wasn’t scalable, so they had to learn how to work through other people with all accompanying imperfections. I guess you won’t argue that an entire department outperforms a single dev in most cases. So you are a single dev now and you need to learn how to run an entire department. That’s where you are if you still don’t use AI.

Now let’s consider a typical flow of any project:

Planning → Execution → Testing → Rollout → Bug fixes

If you apply your new mindset, you do not control execution at all but you are still responsible for results. How to be sure that you get what you wanted?

You need to have a detailed plan with clear acceptance criteria, so it’s objectively easy to determine if the target has been achieved. The validation should be a quick operation, ideally automatic.

• How can you say that the goal was achieved? A unit test, integration test or E2E test. Depends on the goal.

• How can you say that it was done properly? A properly configured linter should cover a big part of it. Everything else should be formulated as Code guidelines and put into repo as an md file.

• If needed write additional scripts that would run complex checks.

Claude Code configuration

To install:

npm install -g @anthropic-ai/claude-code

Claude Code uses a CLAUDE.md file for getting information about the project, you can create this file yourself in the root of the project or ask Claude to review the entire project and generate this file. To do this go to your directory and run in console:

claude

after that type

/init

and you will get a generated CLAUDE.md.

Add something like this to your CLAUDE.md file to be sure that whatever Claude does it will run linter and tests before it considers anything done:

# CLAUDE Development Guidelines

## Core Principles

### 1. Quality Assurance Protocol
**MANDATORY**: All code changes must pass the following checks before considering ANY task complete:

1. **Linter**: Code must pass all linting rules without warnings
2. **Tests**: All existing tests must pass + new tests for new functionality
3. **Type Checking**: If applicable (TypeScript, Python type hints, etc.)
4. **Code Review**: Self-review for best practices and potential issues

### 2. Pre-Completion Checklist
Before marking any development task as "done":

- [ ] **Linter passed** - Zero warnings/errors
- [ ] **All tests passing** - Existing + new test coverage
- [ ] **Code formatted** - Consistent with project style
- [ ] **Documentation updated** - If public APIs changed
- [ ] **Edge cases considered** - Error handling implemented
- [ ] **Performance validated** - No obvious bottlenecks introduced

### 3. Development Workflow

#### For Every Code Change:
```bash
# 1. Run linter first
npm run lint        # or equivalent for the project

# 2. Fix all linting issues before proceeding
npm run lint:fix    # if auto-fix available

# 3. Run tests
npm test           # or equivalent

# 4. Add new tests if needed
# Write tests for new functionality
# Ensure edge cases are covered

# 5. Verify everything passes
npm run ci         # if available (runs lint + test + build) 

Tip: Use https://console.anthropic.com/dashboard for prompt generations or edits to CLAUDE.md

With this setup you already decrease number of reviews needed from your end dramatically. However, your junior partner still needs a lot of information from you:

• details of the task

• design if your task involves frontend

you don’t want to describe it in details, especially colors of your design, so we need to provide tooling to our junior partner. This tooling is called MCP server. There are many of them available already. However, you need to be cautious, as it’s relatively new technology and it opens a new vector of attacks, so better to use only official MCP servers and only ones you actually use. Here is an awesome list of MCP servers.

I personally use only these:

• Linear MCP, so I explain what’s needed to be done only once.

• Figma MCP to provide links to the design, so Claude can get understanding of the design. It uses many tokens though, so better to turn it off and provide screens of the design if you are not on x20 Max plan.

  Tip: Use Ctrl+V(not cmd +v!) combination to insert a picture into claude code

• Serena MCP to give Claude ability to work with code as a code and not simple text. From a pragmatic standpoint it speeds up claude significantly as the time to read files drops.

• Context7 to use up to date technical documentation. Cannot say that it has a big impact as I work primarily with mature tech(who am I kidding, it’s legacy).

There are bunch of MCPs that give an access to browser to Claude, I am afraid to use them now as not enough time passed for them to mature. It wouldn’t speed up me tremendously, so it’s not worth the risk.

Here is my .mcp file that you need to put in the root of the project:

{
  "mcpServers": {
    "Figma Dev Mode MCP": {
      "type": "sse",
      "url": "http://127.0.0.1:3845/sse"
    },
    "linear": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://mcp.linear.app/sse"]
    },
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp"]
    },
    "serena": {
      "command": "/opt/homebrew/bin/uvx",
      "args": [
        "--from",
        "git+https://github.com/oraios/serena",
        "serena-mcp-server"
      ]
    }
  }
}

So now your junior partner has a bunch of tools at their disposal, it’s their first time at work so they will ask for your approval literally for everything, e.g running a linter.

You don’t want to be sitting in front of your laptop entire day and approving simple commands, so let’s provide them a list of allowed tools by default, to achieve that you need to open .claude/settings.local.json file within your project and update “allow“ property:

{
  "permissions": {
    "allow": [
      "Bash(fd:*)",
      "Bash(ls:*)",
      "Bash(rg:*)",
      "Bash(npm run legacy:test:*)",
      "Bash(npm run check-types:*)",
      "Bash(npm run:*)",
      "mcp__linear__get_issue",
      ...
}

I recommend to add all commands that you have in your scripts section of package.json file. You will have an option to update this list when Claude will ask you for permissions, so don’t stress out that you don’t fill in this list fully on a first attempt.

Even with a long list of approved tools, you will still need to provide input to Claude from time to time. To avoid missing it due to multi-tasking I advise installing terminal-notifier package:

brew install terminal-notifier

and add such prompt to CLAUDE.md

On macOS, show toast notification and play sound using:
```bash
terminal-notifier -title "Claude Code" -message "MESSAGE" -sound default
```

Use notifications when:
- Requesting user permissions or approval for tool use
- Completing a major task or set of tasks
- Encountering errors that require user attention
- Finishing execution of long-running commands

voila!

Tips and Tricks

100% brain capacity

If you have the max tier (x20 Max) force your junior partner to use its brain at 100% via switching the model to Opus4, you can achieve it via `/model` command.

Even though you got a better brain, it’s not enough you also need to tell Claude to use it fully via using “think harder“ or “think longer“ in your prompts, it forces Claude to use extended thinking. It’s not some prompt magic - just a feature of Claude Code.

Planning

The main trick is to spend most of your time on planning the execution. First of all, you need to use planning mode via clicking Shift+Tab twice, in this mode Claude won’t touch any of files:

Second, you need to provide all important documentation, you can refer to files by using`@`

Third, to speed up development you need to come up with a plan that can be split among several agents. I create a plan together with Claude, after that I ask it to create detailed tasks with clear dependencies between them, so it can be given to a dev team. After that I ask what would optimize size of people working on this feature in parallel and based on the answer, I ask it to implement the feature (don’t forget to quit planning mode) with n sub-agents in parallel. It’s crucial to mention that they have to work in parallel because Claude is lazy and would do it sequentially by default.

Low-hanging fruit

You will notice that Claude reads a lot of code and does many operations with files(Serena MCP helps but doesn’t solve it fully), so it’s worth to replace default command-line tools with more performant ones. So I recommend to install these 3

brew install fd rg sd

and add this prompt to CLAUDE.md

Always use modern Rust-based CLI tools:
- fd instead of find
- rg (ripgrep) instead of grep
- sd instead of sed

These tools are already installed on the system.

You will feel the difference only on big projects though.

Documentation

When feature is ready, I highly recommend to ask Claude to summarize the feature and create an md file in docs directory with several sections - product requirements, how the feature works end-to-end and what tradeoffs this solution has.

The context window of Claude is small, so it would be reset quite often. Having these docs helps to save time on parsing entire project when you need to do follow-up tickets. Btw, don't shy away from using Claude to create follow-up tickets in Linear, it does an amazing job with it.

Github

Claude Code knows how to work with `gh` tool out of the box, so you just need to install it on your system via:

brew install gh

I primarily use it for commit creation as I’m lazy to type proper commit messages (who isn’t?!) and to do an initial code review of PRs. You just need to use the /review command within Claude and specify PR id or simply explain what’s PR about, it will find it, review and provide comments for improvements. You can also specify a focus of the review via prompt, e.g., review as a Security engineer.

Welcome to the other side

After you use Claude Code for a while, you'll highly likely get a rough awakening. Like one of my senior engineers had this week:

Happy shipping!

Thanks for reading Leprik! Subscribe for free to receive new posts and support my work.