claude-code

My Claude Code Setup in 2026: MCP Servers, Hooks, Skills, and What I Actually Use

Daniil Okhlopkov

• 7 min read
My Claude Code Setup in 2026: MCP Servers, Hooks, Skills, and What I Actually Use

Claude Code is Anthropic's AI agent that runs in your terminal. It reads your files, runs shell commands, browses the web, and calls APIs. You type what you want, it figures out the how. I've been using it daily for 4 months, and this is my actual setup — not a tutorial rewritten from docs, but how I work.

What Claude Code Actually Is (and Isn't)

Claude Code is not a chatbot. It's not autocomplete. It's basically a while True loop in your terminal — the agent gets a task, picks a tool, runs it, looks at what happened, figures out the next move. Keeps going until done or until it gets stuck and asks you.

The tools are real: file access, bash, web search, MCP servers. No IDE in between. You cd into your project, type claude, and that's it — you're talking to something that can see your entire codebase and actually do things with it.

Pricing: $20/month gets you the Pro plan with limited usage. $100/month (Max) is unlimited — that's what I use. There's no free tier for Claude Code specifically. You need a Claude subscription, then install it via npm install -g @anthropic-ai/claude-code.

How I Use Claude Code Daily

My daily workflow looks nothing like traditional coding. I record a voice note in Telegram describing what I need. My server agent (Claude Code running 24/7 on a Hetzner VPS) picks it up, reads the voice transcription, and starts working.

For analytics work, I describe the research question and agent just goes. Writes SQL for Dune Analytics, pulls the data, makes charts, puts together a report. What used to be 3-4 hours of me writing SQL and formatting stuff is now 20 minutes of talking and reviewing.

For code — same thing. I describe what I need, it reads the files, writes the code, runs tests, commits. I look at the diff. Usually accept. Sometimes push back on something in plain English.

Before Claude Code, I'd have 15 browser tabs open: docs, Stack Overflow, GitHub issues, API references. Now I have one terminal window. The agent reads the docs for me.

My CLAUDE.md — The File That Makes It Work

Every Claude Code project has a CLAUDE.md file in the root. When the agent starts, it reads this file first. Think of it as an operating system for your agent, not a prompt.

Here's part of mine (106 lines total):

# Personal Obsidian Vault

## Architecture
- **Keep files short** (<150 lines). Use [[links]] for navigation.
- **AI never edits raw content.** Voice notes stay pristine.

## Voice Messages
When receiving a voice note:
- If about a specific project → save to: projects/X/ai-docs/
- If personal → save to: personal/diary/

Then:
1. Add tags and project links below raw text
2. Extract TODOs → project-specific tasks.md
3. Facts about projects → projects/X/overview.md

This file routes everything. Voice notes, tasks, credentials, project structure — the agent figures out where stuff goes based on these rules. I update it maybe once a week when something in my workflow changes.

The key insight: CLAUDE.md is not about telling the agent what it is. It's about telling the agent how your world works. Project structure, naming conventions, where things live, what to never touch. I wrote more about this pattern in Building a Second Brain with Obsidian and Claude Code.

MCP Servers I Use Daily

MCP (Model Context Protocol) lets Claude Code talk to external services. You define servers in .mcp.json, and the agent gets new tools — basically giving it extra capabilities beyond just reading files and running bash.

Here's my actual .mcp.json:

{
  "mcpServers": {
    "coolify": {
      "command": "npx",
      "args": ["-y", "@masonator/coolify-mcp"],
      "env": {
        "COOLIFY_ACCESS_TOKEN": "${COOLIFY_ACCESS_TOKEN}",
        "COOLIFY_BASE_URL": "${COOLIFY_BASE_URL}"
      }
    },
    "telegram": {
      "command": "python",
      "args": ["telegram_mcp_proxy.py"],
      "env": {}
    }
  }
}

Coolify MCP — my deployment server. The agent can deploy apps, restart services, check logs, manage databases. When I update the agent's own config, it redeploys itself. An AI agent that deploys itself to production.

Telegram MCP — full Telegram access. Read messages, send replies, manage channels. My server agent uses this to answer questions in my Telegram channel discussion while I sleep.

I also use Codex MCP for dual-model review. Claude writes a plan, sends it to OpenAI's Codex for an independent review, then incorporates the feedback. Two AI agents cross-checking each other. I wrote about this setup in Claude Code + Codex Dual Review.

Skills — Markdown That Gives Your Agent Superpowers

A skill is a .md file in ~/.claude/skills/. No SDK, no API, no build step. You write instructions in markdown, and Claude Code follows them when relevant.

Skills I've built:

  • ton-analyst — writes Dune SQL queries for TON blockchain analysis. Knows the schema, the gotchas (like filtering direction = 'in' to avoid double-counting messages), and how to poll the Dune API for results.
  • ton-profiler — investigates TON wallet connections. Calls our internal API, builds graph data, identifies clusters of related addresses.
  • crosspost — publishes content across Telegram, Ghost blog, Twitter/X in three languages (RU, EN, CN).

The skill file for ton-analyst is about 200 lines of markdown. It includes SQL templates, API endpoints, common mistakes to avoid, and example queries. No code — just instructions that the agent interprets and executes.

I made a lot of mistakes building these. If you're starting, read 7 Common Mistakes When Writing Claude Code Skills first.

Hooks — Code That Runs on Every Action

Hooks are shell commands that fire automatically on specific events inside Claude Code. Before a commit, after a tool call, when the agent tries to edit certain files — you can intercept pretty much anything.

Example from my setup — a pre-commit hook that prevents the agent from committing sensitive files:

# .claude/hooks/pre-commit.sh
# Block commits that include credential files
if git diff --cached --name-only | grep -qE '\.(env|key|pem)$|creds\.md'; then
  echo "BLOCKED: Attempting to commit sensitive files"
  exit 1
fi

This is what makes it possible to run Claude Code unattended. My server agent works 24/7 and I don't worry about it leaking credentials or pushing to the wrong branch — because hooks won't let it.

Subagents and Teams

Claude Code can spawn sub-agents — think of it as a lead who delegates. The main agent splits the work, launches a few workers, and they all run in parallel with their own context windows.

I use this for blockchain research. The lead agent gets a question like "analyze this wallet's activity over the last 30 days." It spawns:

  • A data agent that writes and runs SQL queries on Dune
  • A profiling agent that checks our internal wallet database
  • A report agent that takes both outputs and builds the final analysis

Three agents working in parallel, each with their own context. The lead coordinates. What would take me half a day finishes in 15 minutes.

Teams take this further — multiple named agents with persistent task lists, working on a shared project. I've used teams for large research reports where one agent gathers data, another writes sections, and a third does quality review.

Claude Code vs Cursor — When I Use Each

I still have Cursor installed. Here's when I use what:

Cursor wins for:

  • Quick inline edits — you see the code, highlight a block, ask for a change. Visual and fast.
  • Exploring unfamiliar codebases — Cursor's UI lets you click through files while the AI explains things.
  • When you know exactly what you want changed and where — pointing is faster than describing.

Claude Code wins for:

  • Anything that needs more than just editing code — if the task involves bash, API calls, file reads, and edits all together, Cursor can't really do that.
  • Autonomous workflows — background agents, server deployments, scheduled tasks. Cursor needs you sitting in front of it.
  • Large-scale changes — refactoring across 20 files, running tests after each change, fixing what breaks. The terminal is faster than the GUI for this.
  • Integration with external systems — MCP servers let the agent talk to Telegram, deploy to production, query databases. Cursor's tool integration is more limited.

My ratio: 90% Claude Code, 10% Cursor. But that's because most of my work is data analysis and agent orchestration, not UI development. If I was building React components all day, Cursor would probably win.

Costs — Is $100/Month Worth It?

Claude Pro ($20/month) gives you limited Claude Code access. Good for trying it out, learning the workflow, running simple tasks. You'll hit rate limits on heavy days.

Claude Max ($100/month) removes the limits. I switched after 2 weeks on Pro because I was hitting the ceiling daily. At $100, I never think about usage — I just use it.

Is it worth it? My time at work costs way more than $50/hour. If the tool saves me even 2 hours a month it's already paid for. And honestly it saves me closer to 2 hours per day. SQL queries alone used to eat hours. Now the agent handles data formatting, charts, report writing — all of it.

Real numbers from February 2026: I ran the agent for a blockchain research project that produced a 30-page report with 15 charts and 40+ SQL queries. Doing this manually would have taken me a full work week. The agent did it in one evening while I reviewed the output.

The Second Brain Pattern

Everything above connects through one idea: the agent lives inside my Obsidian vault. My notes, project files, tasks, voice transcripts — they're all in one directory. Claude Code reads them and knows what I'm working on, what's pending, and how my projects are structured.

I call it a "second brain" because that's literally what it is. I dump thoughts into voice notes, the agent organizes them. I have ideas at 2am, the agent picks them up in the morning. My project context is never lost — it's in markdown files that both the agent and I can read.

The deeper version of this — packaging your entire professional identity into a format AI can work with — is what I wrote about in dania.zip: Packaging Yourself for AI Agents.

What This Actually Changed

Four months in, the biggest shift isn't productivity. It's that I stopped context-switching. I used to juggle between SQL editor, terminal, browser, Slack, Notion, and my code editor. Now I sit in one terminal and describe what I need. The agent handles the rest.

I'm not writing less code — I'm writing no code for most tasks. Agent writes, I review. The job became less about typing and more about knowing what needs to exist and wether it's correct.

If you want the full deep dive into my workflow, start with my workflow post. For the Obsidian integration, see the second brain post. And if you want to build skills, start here.

Daniil Okhlopkov — Head of Analytics at TON Foundation. Building AI agent workflows, blockchain analytics tools, and writing about it.

Telegram · Twitter/X · YouTube · Instagram