Claude Code Training for Dev Teams: Agentic Work on Your Repo (2026)

The AI-Native course by Syntalith teaches agentic work to teams that build software: how to drive Claude Code, Codex, and the tools that come after them, on your repo. Pricing is quoted after a call. The adjacent line, AI (Claude) training for companies, starts at €1,200 net per day. For developers, technical founders, and solo builders, not non-technical teams.

"Claude Code training" and "how to build AI agents" are usually the same question asked two ways: how to get a team building with agents fast and sensibly, instead of fixing up after them at night. The answer does not live in one tool. It lives in a method that works on your code and survives the next model release.

Quick answer

The AI-Native course is a course in working with agents, run on your code, not a shelf package:

• Format: 1:1 or a small team cohort, online, on your real repo.
• What it installs: review of agent-written code, shared conventions, operating boundaries, and evaluation of the result.
• Who teaches: engineers whose agent-built systems run in production today.
• Price: quoted after a call about your repo; the adjacent line, AI (Claude) training for companies, from €1,200 net per day.
• How we start: a call about the repo, then a quote and plan, then working sessions on real material.

The full program and formats are on the AI-Native course page.

How is the course different from a general AI course?

A general AI course raises AI literacy across the company: it shows the tools, prompting, and where a generative model helps in daily work. Its audience is usually a team that does not write code. If that is what you need, the right address is AI training for teams, not this course.

The agentic-work course solves a different problem, the one keeping team leads up at night in 2026: agents write code faster than the team can trust it. The diff arrives in minutes, and review chokes week over week, because every commit has to be read twice, hunting for the spot where the agent did something almost right.

The course installs exactly what sits between speed and trust:

• review that scales faster than the number of diffs,
• conventions shared across the team, so everyone drives the agent the same way,
• boundaries the agent works inside, instead of improvising,
• evaluation that checks the product's behavior, not tests the agent wrote for its own code.

It is the same method our own production work stands on.

Who is it for, and who is it not for?

The course is for people who write code day to day: developers on a team, technical founders, and solo builders with a real repo and a real goal. We match the depth to who is in the session, but everyone leaves with a method that stays in daily work.

Do not buy the course if:

• your team does not write code day to day: AI training for teams, aimed at AI literacy, is the right fit,
• you want us to build the system for you: start with a process scan and an implementation (scopes and ranges are in the pricing),
• you are after a certificate for the wall or a no-code promise,
• you expect production maintenance, ownership, and an SLA from a course.

If any of these describe your case, we will say so on the call, before you see a quote. We would rather send you where it actually helps.

What does a day of work on your repo look like?

The course starts with a single call about the project, stack, and goal. From there we run it in a clear order: a conversation about the repo, a quote and a plan matched to the project, then online working sessions on your real material.

The sessions are not a lecture about trends. The threads form around your goal:

• how agents actually work, and where the answers that only look true come from,
• how to move from "the agent probably did it" to "you can trust it",
• how to drive an agent inside boundaries so the result is repeatable and production-ready,
• how to write requirements as acceptance tests the agent must pass before the result reaches review,
• how to keep context and cost inside a budget on a longer task,
• how to close the learning with a pilot and, as you grow, onboard the team with the same method.

We work mostly on Claude and Claude Code, as we build ourselves, but the method is tool-agnostic: we also teach on Codex and the tools that come after, if that is what you use. We say plainly where another model or tool fits better.

What does it cost, and what drives the quote?

The course price is quoted after a call, because scope varies too much: 1:1 on a single repo is different work from a team cohort on shared code. We give you a real number after one conversation about the repo and the goal, not from a rate card. The quote depends on format, your stack, headcount, and scope.

For comparison, three typical paths:

Open market courses can be cheaper per head, but they teach on a shared syllabus, not on your repo, so the conventions and boundaries meant to stay in the team still have to be built afterward yourself.

The adjacent line, AI (Claude) training for companies, has a rate up front: from €1,200 net per day, with possible KFS co-funding that the employer applies for. Five of those trainings have so far run as 1:1 sessions on a participant's own process. That is a separate line from the agentic-work course; full rates and scope are in the pricing.

Before you ask for a quote, count your own cost of review. This is a formula you fill with your numbers:

Weekly cost of reviewing agent-written code =
  hours spent reading diffs per week
  x number of people who do it
  x cost of an hour of work

If that cost grows faster than the team does, the bottleneck is review, not the number of hands on the code.

What do you keep after the course?

After the course, what stays with you is a method, not a dependency on us. Specifically:

• a written, repeatable harness for working with agents, embedded in your repo,
• templates and conventions the whole team uses to drive the agent the same way,
• a way to verify results where a green run really means "it works",
• a pilot: a slice of work done with the new method that you return to on Monday.

You pay once; the method and what you walk away with stay yours. When the team grows, you onboard the next people with the same method.

If you would rather have the system built and maintained than have your team build it, that is a separate path: production hardening, ownership, and maintenance stay a paid implementation. Start there with a free process scan, and we will say plainly what is worth building, and whether it is worth building at all.

What next: if you first want to understand what agentic work is and where an agent makes sense, start with the guide on what an AI agent is. If you have a repo and a goal, let's talk about the course.