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