Claude Code & Agentic AI

About the Claude Code & Agentic AI

From first install to production-grade AI agents

Our Claude Code training is designed for teams that want to move beyond chat assistants and build real agentic workflows: AI that reads your files, runs your tools, remembers your conventions, and ships verified work.

In practice, participants learn to:

• install and configure Claude Code on Windows, macOS or a server,
• structure project memory with CLAUDE.md, MEMORY.md and lessons files,
• enforce guardrails with permissions and hooks,
• extend the agent with skills, sub-agents and MCP servers,
• integrate Git and GitHub for safe, traceable automation.

eaQbe methodology: built on a real production system

This training is not a slideware tour. It is distilled from eaQbe's own production platform: an agentic system that runs daily on a server, orchestrated end-to-end by Claude Code. Every pattern taught in the room (memory, hooks, verification, autonomous loops) has been battle-tested in production.

Our approach follows the same progressive logic as all eaQbe trainings:

• Understand before you build
• Use before you implement
• See the end goal before diving into technical details

Learning path

1) Use Claude Code like a power user

Participants start by driving Claude Code on a real project: sessions, context management, plan mode, slash commands. The goal is to understand what a well-configured agent can do before configuring one.

2) Memory & configuration

The three-file memory pattern (CLAUDE.md, MEMORY.md, lessons), settings and permissions, and the hook system that turns team conventions into enforced rules.

3) Skills, sub-agents & MCP

Write a custom skill, dispatch sub-agents for parallel work, and connect MCP servers (persistent memory, databases, browsers) to give the agent real capabilities.

4) Production patterns

Git integration, headless automation, verification discipline, and a ready-to-copy configuration standard distilled from our production system.

What you leave with

Participants do not leave with a chatbot. They leave with the blueprint of a small team: an agent that has an identity, rules it cannot forget, a memory that outlives the session, a clock, and hands. Every piece below is installed in the room, on a real project:

• An identity: a CLAUDE.md stating who the agent is, what it never does, and which projects it owns. Short by obligation, because a charter nobody finishes reading stops being followed.
• Guardrails and hooks: permissions, plus reflexes executed by the harness rather than by the model. A destructive command is refused, code is checked right after it is written, an undated project state is flagged at the end of the turn. The agent can neither forget them nor talk its way around them.
• Canaries: the daily rounds. A hook catches a gesture, a canary catches a silence: a memory that no longer writes, a backup that has aged, a configuration that drifted, a living document describing a state that no longer exists. Each one emails you, with the name of the thing.
• Persistent memory: decisions, their reasons and the lessons learned, kept outside the session and re-read at the next one. Written, then read back, because an unverified write is not a write.
• A knowledge graph: the map of your files, functions and their dependencies. It answers the question plain text search cannot: what breaks if I change this.
• A scheduler: the clock. It fires work at a fixed hour, keeps the trace of every run, and writes to you when one fails. No intelligence at all, and that is exactly its quality: it cannot improvise.
• A wake-up ritual: one command that opens the session with a mandatory reading list and demands a single line back. Without it, an agent that starts cold does not say “I do not know”: it fills the gap, confidently, and advises you on a system that no longer exists.
• Skills: the procedures you only want to get right once, written down and invoked, never re-derived from memory.
• An independent reviewer: a second agent, fresh context, whose only job is to criticise the first one's work. The author is never the judge.
• Backups: an encrypted archive, off the machine, read back from where it landed. A backup that has never been restored is a hypothesis.
• Project discipline: one dated state document per project as the single source of truth, a sprint board when the work runs in sprints, a backlog for what waits, and a lessons journal that starts empty on purpose, because a lesson is earned and not copied.

One sentence governs the whole thing, and it is the one to leave with: it proposes, a human applies. The agent puts its work on a branch marked for review, a second agent criticises it, and you decide. Nothing reaches production because a model sounded confident.

Everything assembled during the day leaves with you: a configuration standard you copy into the next project, and the reasoning behind each piece so your team can extend it without us. That is what building capability rather than dependency means here.

Practical details

• Format: 1-day intensive workshop (hands-on & scenario-based)
• Group size: 5–10 participants (small groups for personalized coaching)
• Prerequisites: none, comfort with a terminal helps
• Follow-up: evaluation + post-training anchoring exercises

Foundations & first agent

1.1 Agentic AI foundations

From chat assistant to autonomous agent:

• What Claude Code is and how the agent loop works
• Where agentic AI fits in a data and automation strategy
• Platforms: Windows, macOS, server (VPS)

1.2 Install & first configuration

Getting a working, safe setup:

• Installation and authentication
• Project memory: CLAUDE.md, MEMORY.md, lessons files
• First real session on a sample project

1.3 Driving the agent

Working effectively with an agent:

• The session start ritual: mandatory readings and a one-line status
• Context management and @ mentions
• Plan mode, thinking mode, slash commands
• Reviewing and steering the agent's work

Extending & industrializing

2.1 Configuration & guardrails

• settings.json and the permission model
• The hook system: session start checks, pre/post tool-use guards, lint on save
• From written rule to hook: criteria for mechanising a rule

2.2 Skills & sub-agents

• The SKILL.md format and when skills beat prompts
• Writing a custom skill for a recurring workflow
• Dispatching sub-agents and parallel work

2.3 MCP & persistent memory

• Model Context Protocol: connecting databases, browsers and files
• Persistent memory across sessions, written and then read back
• The knowledge graph of a codebase: what breaks if I change this

2.4 Git, GitHub & automation

• Safe commit workflows and traceability
• Headless mode and scheduled agents

2.5 Production standard

• Verification discipline: proof requirements before closing a task
• A ready-to-copy project template, governance and cost control

Governance, monitoring & autonomy

3.1 The clock and the rounds

• Turning a recurring task into scheduled work, with its own trace and its own failure email
• Concurrency control: preventing double runs
• Canaries: detecting tasks that silently stop running
• Alert thresholds: calibration against alert fatigue

3.2 The independent reviewer

• Delivery on review branches: the awaiting-review workflow
• Independent review: a second agent in fresh context
• The operating contract: it proposes, a human applies

3.3 Project discipline that survives the session

• The dated state document: one source of truth per project
• A sprint board for work run in sprints, a backlog for what waits
• The lessons journal: one line per correction, re-read at every session
• The cold-restart brief: resuming a project from documents alone

3.4 Backups and recovery

• Backup scope: only what exists nowhere else
• Encrypted, off the machine, and read back from where it landed
• The restore drill: timed recovery on a clean machine

Frequently asked questions

Who is the Claude Code training for?

Developers and technical profiles who want to move from chatting with AI to running AI agents that do real work: writing code, executing commands, managing files, committing to Git. Comfort with a terminal and a code editor is the only real prerequisite.

How is Claude Code different from a chatbot?

A chatbot answers; Claude Code acts. It reads your codebase, runs commands, edits files, calls external tools through MCP servers and commits its work to Git, within the permissions you define. The training works exactly on that boundary: what to delegate, what to gate behind approvals, and how to verify.

Is this training based on real production experience?

Yes. The trainers operate agentic AI systems in production, and the curriculum comes from that practice. The modules on monitoring canaries, independent review, backups and verification discipline exist because autonomous agents on live systems fail in specific ways, and we have met them.

What do participants leave with?

A working setup on their own machine: agent identity and project memory, hooks and permissions, custom skills, sub-agents, MCP servers, a knowledge graph, scheduled autonomous work and Git integration, configured during the training and ready to keep running afterwards.

Do we need a Claude subscription?

Yes. Claude Code runs on a Claude subscription or Anthropic API access. We confirm the setup with you before the session, so participants arrive with a working environment and the training time goes into building agents rather than installing software.

Can the training adapt to our stack?

Yes, and it should. The agent patterns are the same everywhere, but hooks, MCP servers and skills are wired to your tools: your repositories, your CI, your databases. Sessions run in French or English, on-site across Belgium and Luxembourg (we are based in Brussels) or remotely.