AI-Native Engineering Training with Claude Code
A dedicated programme for enterprises and individuals to move from personal ad-hoc AI usage and vibe coding to Agentic Engineering at team and organization level.
Dedicated training for your organization, starting with at least 25 people
- 20+ practical tasks, targeted to your Product/Platform or provided by us
- Team Homework analysis provided by our experts
- Conducted in your ecosystem: recordings and supplementary materials stay with you
- Designed for Engineering organizations: Software Engineers, Architects, Quality Engineers, Data Engineers and other roles
- Customized Hands-on Workshops & Hackathons tailored to the team and challenges
- Product & Delivery Track available: a parallel programme for Product, BA, Delivery and QA roles — no code required
Public training for smaller teams under 25 people and individuals
- 20+ practical tasks, bring your own repository
- Recordings are available for a recap, supplementary materials stay with you
- Designed for Software Engineers, Architects, Quality Engineers, Data Engineers and other roles
From Individual Usage to
Team-Scale AI-Native Engineering
Ad-Hoc
Structured
Spec-driven workflows, test-first discipline, safety nets in place
Integrated
CI/CD pipelines, oversight frameworks, team-wide conventions
Agentic
Multi-Claude orchestration, measurable velocity gains, continuous improvement
Ad-Hoc
Structured
Spec-driven workflows, test-first discipline, safety nets in place
Integrated
CI/CD pipelines, oversight frameworks, team-wide conventions
Agentic
Multi-Claude orchestration, measurable velocity gains, continuous improvement
Live facilitated sessions
4-5 hours per week of hands-on labs, group discussions, and practice with expert guidance.
Self-paced video lessons
2-3 hours of pre-session content covering core concepts and theory.
Real code, not toy demos
From Week 2, apply everything to your own production codebase. Bring Your Own Brownfield.
Trained by Practitioners
Our Trainers are ENDGAME AI-Native Practitioners whose mastery comes from 10s of successful engagements.
Hand-crafted materials
Shared Materials are hand-picked and crafted by ENDGAME Practitioners.
Homework evaluation
For Dedicated training our Practitioners provide a summary of a weekly team work.
Core Concepts
Prerequisites check
Git, terminal, code reading, and development fundamentals you should be comfortable with before Week 1.
Tool setup
Node.js 18+, Claude Code, Git with worktree support, GitHub with Actions. Verify everything works on a sample repo.
Foundation videos
Five 30-minute modules: agentic AI concepts, how Claude Code works, AI across the SDLC, ethics and responsibility, and which Claude surface to use when.
Choose your codebase
Pick a production codebase for Weeks 1-4. Active development, reasonable complexity, some technical debt.
Labs & Practice
- Install and verify all tools
- Run Claude Code on a sample repo
Core Concepts
CLAUDE.md configuration
Project-level configuration files that tell Claude how to work. What to include, what to exclude, and where to put them.
Prompt patterns & token economics
Imperative, exploratory, constrained, verification, and decomposition patterns. Managing context size and cost.
Systematic exploration & planning
Architecture first, then flows, then edge cases. The explore-plan-code-commit workflow: turn vague requirements into concrete implementation plans.
MCP servers
Connect Claude to external systems: databases, APIs, browsers, documentation. Week 1 covers the setup — add servers, scope them, keep secrets in the environment.
Skills, output styles, hooks & custom agents
Skills in .claude/skills/, output styles, hooks (30 lifecycle events), and custom agents. Automate formatting, linting, and dangerous-command blocking.
Harness engineering (capstone)
Treat your setup as a designed system with seven components — context, tool surface, control flow, quality gates, reliability, observability, effectiveness levers. Diagnose, design, and audit it.
Context engineering & session mastery
Why a long window is read non-uniformly, and the techniques that carry work past it. Read the context budget on demand, and keep a multi-hour session on the rails across a reset.
Labs & Practice
- Explore a sample repo and document three non-obvious insights
- Create and refine a CLAUDE.md file, test effectiveness
- Apply prompt patterns to 10 tasks
- Create architecture documentation for a legacy codebase
- Configure MCP servers (filesystem, Playwright)
- Build an extension stack: a skill, a hook, and a custom agent working together
- Compose a team harness touching five of the seven components
- Keep a long session on the rails across a context reset
- Draft a CLAUDE.md for your brownfield codebase
Core Concepts
Why specifications matter
Vibe coding fails at scale. Specs are the single source of truth for both you and the AI. Functional requirements, acceptance criteria, constraints.
Three intensity levels
Spec-first (complete before coding), spec-anchored (living document), spec-as-source (humans edit specs, AI generates code). Match intensity to task size.
The four-phase workflow
Specify (what, not how), Plan (stack, architecture, constraints), Tasks (small, reviewable chunks), Implement (one task at a time, commit often).
Human review gates
Add judgment between phases. The compound error problem: 100 steps at 1% error rate = 63% failure probability. Gates interrupt the cascade.
EARS notation
Five patterns for unambiguous requirements: ubiquitous, event-driven, state-driven, unwanted behaviour, and optional.
SDD tools
Spec-Kit, OpenSpec, GSD, BMAD Method, or the manual four-file approach. Pick what fits your context.
Property extraction
Turn a specification into properties an agent can test against — the bridge from EARS requirements to property-based testing.
Labs & Practice
- Expand a vague feature request into a full specification
- Execute the four-phase workflow end to end
- Convert requirements into EARS notation
- Practice the iterative workflow: change, verify, commit, repeat
- Write a specification for a pending feature in your codebase
- Apply the workflow through Phase 3 on your codebase
Core Concepts
Understanding legacy code
AI gives a head start but lacks domain expertise. Watch for shepherding, drifting, and the illusion of competence.
The four-phase refactor loop
Scene & Plan, Tests, Iterate, Land. Characterisation tests as the safety net, surgical edits reviewed diff by diff, zero regressions.
PAID framework
Prioritise (high debt + high value), Address (low debt + high value), Investigate (high debt + low value), Document (low debt + low value).
TDD with AI
Write tests from input/output pairs first. Confirm they fail. Then implement. Verify in a fresh session to catch overfitting.
Security & compliance
OWASP Top 10 review. Secret management. Licence compliance. Constitution files in CLAUDE.md. Audit trails.
Controlling what Claude can do
Contain what the agent can do, not just what it writes: the sandboxed Bash tool, permission rules (allow/ask/deny), and blocking hooks. Use the lowest layer that owns the action.
Diagnosing AI failures
Context pollution, prompt ambiguity, knowledge gaps, pattern mismatch. The Thread Fold technique for recovery.
Compound engineering
The step teams skip. Encode each lesson at the right altitude — a one-off becomes a regression test, a thrice-repeated rule a CLAUDE.md line, a recurring workflow a skill. The rule of three keeps it from becoming clutter.
Labs & Practice
- Implement a feature with strict TDD, verify in fresh context
- Generate characterisation tests for undocumented legacy code
- Conduct a security audit of AI-generated code
- Refactor a high-complexity module through all four phases
- Categorise technical debt using the PAID framework
- Build a PreToolUse guard hook to block an unsafe action
- Add characterisation tests to a low-coverage module in your codebase
Core Concepts
CI/CD integration
GitHub Actions with claude-code-action for PR reviews. Headless mode for automation. Automated gates: coverage, docs, breaking changes.
Multi-Claude orchestration
Orchestrator-worker, writer-reviewer, parallel execution with Git worktrees — and the production recipes that implement them, with error handling, retries, audit logs and budget caps.
Oversight & governance
Human-in-the-loop, human-on-the-loop, autonomous with audit. Match oversight level to task risk, and make it hold at team scale.
Team coordination standards
Standardise practice through path-scoped rules files, plugins, and shared memory. From personal setup to team convention.
Loop engineering
Build the outer loop that runs an agent without you: trigger, body, stop condition, and a checker that is not the maker. Budget it by cost per closed task.
The agentic platform
Drive Claude programmatically through the Agent SDK and Agent Teams, and understand MCP deeply enough to build your own server. From personal CLI to team platform.
Labs & Practice
- Automate one step of your PR flow in CI/CD
- Run a multi-Claude pattern and check it earned its tokens
- Ship a production orchestration recipe with retries and audit logs
- Calibrate oversight and enforce one boundary
- Standardise one team convention (a rules file or plugin)
- Design an oversight framework for your team
25% OFF
Standard €3,000 → €2,500 per individual seat
Dedicated
ON REQUEST
Up to 40 to 100 engineers
UP TO 50% OFF FROM €3,000
Public
€2,500
per seat
25% OFF
25–49
€2,250
50+
€2,000
You should be comfortable with the following before starting the programme.
Git
Branching, merging, handling conflicts
Terminal
Comfortable working in a command line
Code
Proficient in at least one programming language
Fundamentals
Basic software development concepts