Claude Code – autonomous agent development & MCP integration (CLPRG1)

AI - Artificial Intelligence, AI for developers

This hands-on course helps experienced developers adopt Claude Code into real development workflows. You will operate controlled agents in both IDE and terminal, work with prepared code fragments and projects, and practice safe, repeatable AI-driven development.

Through practical exercises, code review and TDD you will build CLAUDE.md, manage memory, define guardrails and implement hooks, custom commands and skills. The course covers MCP integration and multi-agent pipelines for production use.

THIS TRAINING COURSE WILL HELP YOU:

  • Understand LLM principles and agent architecture
  • Set up and use Claude Code in IDE and terminal
  • Create CLAUDE.md and manage project/user memory
  • Design and enforce guardrails and security constraints
  • Develop and test code with agents in a TDD workflow

WHO SHOULD ATTEND?

  • Developers integrating AI into development workflows
  • DevOps and platform engineers managing MCP servers
  • Tech leads and architects designing agent solutions
  • QA engineers and automation specialists

COURSE LOCATION AND AVAILABLE DATES



Choose whether to attend in person in our classroom or join online. You can select your preferred format during registration. Learn more about hybrid training.

Public courses are usually delivered in Czech, but this course is also available in English. We can arrange private training for your team online, at your premises or in our classrooms, and tailor the content to your needs.

For groups of around 4 or more participants, private training can already be comparable in price to booking individual places on a public course. Send us your requirements and we’ll recommend the best format and provide an exact quote.

Request training in English

Course content:

Hide details
  • From chat to agents
    1. History of LLMs
    2. Inner workings of LLMs
    3. What an agent is and its components
  • Claude Code in the IDE
    1. Plugin installation (VS Code / JetBrains)
    2. Inline edits vs side-panel conversations
  • Claude Code in the terminal
    1. CLI workflow and when it's faster than an IDE
    2. CLI-driven development without opening files
  • Context for the agent: CLAUDE.md and memory
    1. Why context determines output quality
    2. Structure of a good CLAUDE.md
    3. Auto-memory; project vs. user memory
  • How to craft an effective prompt
    1. What makes a prompt effective for an agent
    2. Specificity, examples, constraints, verification asks
    3. Iterating prompts during a task
  • Navigating unfamiliar code
    1. Delegate "how does this work?" to the agent
    2. When to trust synthesis and when to verify
    3. Spot-checking architectural claims
  • Planning and limits for agents
    1. Plan mode and agreeing on changes before implementation
    2. Small steps and iterative changes
    3. Scope control — stopping unrelated refactors
  • How to review code produced by an agent
    1. Reading AI-generated diffs
    2. Hallucinations and fabricated APIs
    3. Review fatigue and mitigation strategies
  • Tests and test-driven development
    1. Why tests are more crucial when shipping with AI
    2. TDD workflow with an agent
    3. Reviewing AI-generated tests with the same skepticism as code
  • Git workflow and gh CLI
    1. Creating pull requests via gh CLI
    2. AI-assisted diff review
  • Autonomy and guardrails
    1. Spectrum of agent autonomy: default, acceptEdits, plan, auto, bypassPermissions
    2. Auto mode and configuring autoMode.environment
    3. dangerously-skip-permissions and managed team settings
  • Claude Code hooks
    1. Pre/post-action hooks (formatter, linter, custom rules)
    2. Hook events: PreToolUse, PostToolUse, Stop and others
    3. Hooks to enforce project conventions: /loop, /schedule and built-ins
    4. /loop and /schedule — repeated and scheduled tasks
    5. Context management: /clear, /compact, /memory
    6. Session configuration: /model, /config, /permissions
  • Creating custom commands
    1. Anatomy of a custom command in .claude/commands/
    2. $ARGUMENTS templating
    3. Sharing commands across the team
  • Using skills
    1. What a skill is and how it differs from a command
    2. Discovery — how an agent detects available skills
    3. Applying skills to real tasks
  • Building custom skills
    1. Skill structure (metadata header, content, examples)
    2. Description as a trigger
    3. Packaging and team distribution
  • MCP servers — practical use
    1. MCP mental model
    2. Confluence MCP server
    3. MCP vs plain CLI usage
  • Custom MCP server
    1. MCP protocol in depth
    2. Server structure and tool definitions
  • Multi-agent workflow and spec-driven development
    1. Sub-agents: planner / executor / verifier
    2. Superpowers plugin and get-shit-done (gsd)
    3. When multi-agent pipelines make sense and when not
  • Remote control and Claude Code channels
    1. Claude Code from anywhere (mobile, second machine, on-call)
    2. Channel plugins (Telegram and others)
  • Building your own end-to-end application
    1. Setting up a small project
    2. Full workflow: context → plan → test → PR
    3. Summary of pitfalls and enterprise deployment considerations
Prerequisites:
Experience in software development, routine use of Git and familiarity with an IDE (VS Code, JetBrains, etc.).
Schedule:
2 days (9:00-17:00)
Price per person:
632.00 € ( 764.72 € incl. 21% VAT)

Training and learning environment