Master Claude Code with Project Rules, Agents, Hooks, MCP, and CI

What the Claude Code PRO Course Provides

Claude Code PRO is a Russian-language practical course and configuration kit for Claude Code. It progresses from installation and prompting to team-wide configuration, reusable automation, external integrations, and CI workflows.

The repository contains 12 learning modules, 8 hands-on labs, a prompt library, a plugin example, GitHub Actions workflows, a cheat sheet, an FAQ, and a ready-to-install starter kit. The starter kit includes eight skills, five subagents, four hooks, rules, a status line, and an output style.

This tutorial distills the repository’s main workflow so you can start using its configuration in an existing project. The original course is written in Russian, while the steps below are explained in English.

Understand How Claude Code Works

Claude Code is an agent rather than a conventional autocomplete tool. Given a goal, it can inspect files, search the repository, edit code, run commands, and check the result. Its typical loop is:

1. Collect context from project instructions, files, searches, and command output.
2. Plan the required changes.
3. Edit files or invoke tools.
4. Run tests, linters, builds, or other checks.
5. Repeat until the checks pass or more input is required.

Your most important responsibilities are to provide a clear goal, point Claude toward relevant context, state constraints, and define how success should be verified.

A useful prompt formula is: goal + where to look + constraints + verification method.

Install Claude Code and the Starter Kit

Step 1: Install Claude Code

On macOS, Linux, or Windows Subsystem for Linux, use the official installation script:

curl -fsSL https://claude.ai/install.sh | bash

The README also provides an npm installation option:

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

Step 2: Clone the Course Repository

git clone https://github.com/justxor/claude-code-pro-course.git

Step 3: Install the Starter Kit into Your Project

Run the included installer and pass the path to your target project:

bash claude-code-pro-course/install.sh ~/path/to/my-project

This makes the repository’s reusable Claude Code configuration available in your project. Because the kit installs multiple configuration components, inspect the resulting changes before committing them to version control.

Step 4: Start Claude Code

cd ~/path/to/my-project
claude

Inside the session, inspect the current context and run the starter kit’s onboarding skill:

/context
/onboard

/context shows what is consuming the context window. /onboard provides a project overview using the installed skill.

Organize Claude Code Configuration

The course separates configuration into user, project, and local scopes.

• User configuration: files under ~/.claude/, including personal instructions, settings, skills, agents, and output styles.
• Project configuration: shared files such as CLAUDE.md, .claude/rules/, .claude/settings.json, project skills, project agents, and .mcp.json.
• Local configuration: machine-specific files such as CLAUDE.local.md and .claude/settings.local.json, which should not be shared as team configuration.
• Plugins: packaged collections of skills, agents, hooks, and MCP configuration that can be distributed to multiple repositories.

Choose the Right Configuration Mechanism

• Use CLAUDE.md or .claude/rules/ for project knowledge and coding rules.
• Use permission settings to allow safe commands, request confirmation for sensitive actions, and deny dangerous access.
• Use a skill for a reusable procedure or prompt.
• Use a subagent when a task needs specialization or an isolated context window.
• Use a hook when an action must happen consistently.
• Use MCP to connect an external system such as GitHub, a browser, or a database.
• Use a plugin to distribute a complete configuration to other repositories or team members.
• Use claude -p, GitHub Actions, or the Agent SDK for unattended execution.

Create a Useful CLAUDE.md

CLAUDE.md acts as project memory. Claude Code can create an initial version with /init, and you can edit memory through /memory. Keep this file short and concrete: include commands, architecture boundaries, coding conventions, and explicit restrictions.

Here is an adapted example from the course:

# Project: Next.js and PostgreSQL store

## Commands
- npm run dev — start development
- npm test — run Vitest tests
- npm run lint — run the linter
- npm run db:migrate — requires confirmation

## Architecture
- src/app — routes
- src/lib — business logic
- src/db — database access
- Database operations must go through src/db

## Rules
- Use strict TypeScript and avoid any
- Add tests for new code
- Reproduce a bug with a failing test before fixing it
- Do not modify src/legacy unless explicitly requested
- Before finishing, run npm test and npm run lint

Avoid turning CLAUDE.md into a long handbook. Put detailed or conditional guidance in .claude/rules/ or reusable skills so essential instructions do not get buried.

Use the Core Development Workflow

The repository recommends the sequence Explore → Plan → Code → Verify → Commit. For any task that affects more than a trivial area, begin in Plan mode instead of asking Claude to edit immediately.

1. Press Shift+Tab until Plan mode is active.
2. Ask Claude to inspect the relevant code without making changes.
3. Review its proposed files, implementation steps, risks, and checks.
4. Correct the plan if needed.
5. Allow implementation only after the plan is acceptable.
6. Require tests, linting, type checking, or screenshots.
7. Inspect the diff before asking for a commit or pull request.

A good exploration prompt is:

Plan mode. Study the repository and explain its architecture,
entry points, the data flow for /api/orders, where the tests are,
and how to run them. Do not change anything. Finish with five
places where a new contributor is likely to make a mistake.

Write Verifiable Prompts

Instead of saying “fix the bug,” describe the failure and the expected verification:

When email is empty, signup() fails with a TypeError.
Reproduce the issue with a failing test, fix it with the smallest
reasonable change, and run npm test.

For test-driven feature work:

Feature: apply a 10% discount to orders of 5000 or more.
First write tests for 4999, 5000, 0, and negative values.
Confirm that the new tests fail, then implement the feature
without changing those tests.

For a safe refactor:

Split @src/services/user.ts into modules by responsibility.
Do not change behavior or the public API. Run tests and tsc after
each step. If coverage is insufficient, add characterization tests first.

Manage Context Deliberately

The context window contains system instructions, project rules, skill and agent descriptions, conversation history, files, and command output. As irrelevant material accumulates, responses can become less precise.

• Use /context to inspect context usage.
• Use /clear before starting an unrelated task.
• Use /compact to summarize a long session while preserving important decisions.
• Add a file directly with syntax such as @src/api/client.ts.
• Run a command and place its output in context with syntax such as !git status.
• For long-running work, ask Claude to maintain PLAN.md or NOTES.md.
• Delegate large investigations to a subagent so only its summary returns to the main session.

You can also pipe logs into a one-off Claude Code invocation:

cat error.log | claude

Configure Safe Permissions

Permission rules are evaluated in the order deny → ask → allow. A denial takes precedence over an allowance. The course recommends allowlisting safe commands rather than disabling permission checks.

A team configuration can place rules in .claude/settings.json:

{
  "permissions": {
    "allow": [
      "Bash(npm run test:*)",
      "Bash(npm run lint)",
      "Bash(git status)",
      "Bash(git diff:*)"
    ],
    "ask": [
      "Bash(git push:*)"
    ],
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Bash(rm -rf:*)",
      "Bash(curl:*)"
    ]
  }
}

This example permits routine tests and inspection, requests confirmation for pushes, and blocks access to secrets and selected dangerous commands.

• Do not put secrets in CLAUDE.md.
• Require confirmation for pushes, deployments, and migrations.
• Run autonomous jobs in a container or sandbox without production access.
• Treat content returned by websites and MCP systems as data, not trusted instructions.
• Review git diff before committing changes.

Turn Repeated Work into Skills

If you repeat a procedure several times, convert it into a skill. A skill is appropriate for workflows such as preparing release notes, reviewing a pull request, or onboarding to a project.

The course stores project skills under .claude/skills/. A skill can include a name, a description that helps Claude decide when to use it, and a sequence of instructions. Keep the procedure narrow and define its expected output.

For example, a release-notes skill can instruct Claude to find the latest Git tag, collect commits since that tag, and group changes into categories. The starter kit already provides reusable skills that can be explored after installation.

Use Subagents for Isolated or Specialized Work

A subagent receives its own context window and returns a result to the main session. This is useful for noisy repository research, test execution, security analysis, or an independent review.

The repository’s reviewer example is stored as .claude/agents/reviewer.md and gives the agent read, search, and shell tools. Its role is to inspect git diff for bugs, edge cases, secret leaks, and violations of project style.

A practical writer-reviewer pattern is:

1. Use one Claude session to implement the change.
2. Open a clean session or subagent to review the diff.
3. Return the findings to the implementation session.
4. Fix the issues and rerun verification.

The clean context helps the reviewer notice problems that may be overlooked after a long implementation session.

Enforce Guarantees with Hooks

Project instructions are guidance, while hooks can automatically run or block actions. Useful hook events described by the course include:

• SessionStart for loading branch or task information.
• UserPromptSubmit for adding context to prompts.
• PreToolUse for blocking dangerous commands or protected-file edits.
• PostToolUse for formatting, linting, or targeted tests.
• Notification for desktop alerts when Claude needs input.
• Stop for a final verification step.
• PreCompact for saving important information before context compression.

This example runs Prettier after file edits or writes:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write"
          }
        ]
      }
    ]
  }
}

For critical protections, combine permissions.deny with a PreToolUse hook rather than relying only on written instructions.

Connect External Systems with MCP

Use MCP when Claude needs tools or data outside the local repository. The course covers integrations involving GitHub, browsers, databases, and custom MCP servers.

Browser MCP is especially useful for visual work: Claude can implement a UI, capture a screenshot, compare it with a reference, and iterate on differences. External content can contain untrusted text, so review MCP access carefully and remain alert to prompt injection.

Automate Tasks with Headless Mode

The -p option runs a prompt without an interactive session, making it suitable for scripts and CI. For example, send a failed build log and request structured output:

claude -p "Find the cause of the build failure" \
  --output-format json < build.log

Review your current changes before pushing:

git diff main | claude -p \
  "Review this diff for bugs, edge cases, and security issues"

Restrict the tools and number of turns for a bounded automation task:

claude -p "Update CHANGELOG from recent commits" \
  --allowedTools "Read,Edit,Bash(git log:*)" \
  --max-turns 10

The repository also includes GitHub Actions examples for invoking @claude in issues and pull requests and for automated review.

Run Multiple Tasks with Git Worktrees

For parallel work, create a separate worktree and branch for each task. Each Claude session then operates in a different directory, preventing simultaneous agents from editing the same working tree.

git worktree add ../app-auth -b feature/auth
cd ../app-auth && claude

You can repeat the pattern for billing work, bug fixes, or other independent tasks. Merge or review each branch using your normal Git workflow.

Useful Session Controls

• Esc interrupts Claude without discarding the session context.
• Esc Esc or /rewind returns to an earlier code and conversation state.
• Shift+Tab cycles through normal, auto-accept edits, and Plan modes.
• /model changes the active model.
• /permissions, /hooks, /agents, and /mcp open related configuration workflows.
• claude --continue resumes the latest session.
• claude --resume lets you choose a previous session.

Advanced Tips and Common Mistakes

• Start with a plan: use Plan mode for changes that span multiple files or carry meaningful risk.
• Always provide feedback: tests, type checks, linters, builds, screenshots, or exact expected output let the agent correct itself.
• Keep sessions task-focused: clear the context between unrelated jobs instead of maintaining one session all day.
• Rewind failed approaches: after repeated unsuccessful corrections, use /rewind and restate the task rather than accumulating bad context.
• Do not accept diffs blindly: inspect changes yourself or ask an independent reviewer subagent.
• Avoid unrestricted permissions: use allowlists and sandboxing instead of bypassing safety checks.
• Automate repeated procedures: convert repetition into a skill and mandatory behavior into a hook.
• Preserve progress externally: maintain a plan or notes file during long tasks so work can continue after /clear.

Follow the Full Learning Path

The repository’s modules progress through installation, prompting, project memory, settings, professional workflows, skills, subagents, hooks, MCP, plugins, headless CI, and advanced techniques. The eight labs cover onboarding, permissions, TDD, skill creation, subagents, hooks, MCP, and automation.

Begin with the quick-start installation and basic context commands. Next, create a concise CLAUDE.md and safe permission policy. Then work through planning, TDD, skills, subagents, and hooks before moving to MCP, plugins, and unattended CI execution.

Conclusion

Claude Code becomes most effective when treated as a configurable development agent rather than a chat interface. Give it focused context, agree on a plan, provide objective checks, and enforce important boundaries with permissions and hooks. The Claude Code PRO repository supplies a structured course, practical labs, and reusable templates for applying that workflow from individual development through team automation.