Professional training course on the structured adoption of artificial intelligence in software development, aimed at developers and technical leads who want to bring coding agents and language models into their team's work while keeping control over the architecture and the quality of the code. The course covers both frontier models, used as a service, and open-weight models run locally.
The reference tool is Claude Code; the course also gives an overview of alternative harnesses, and the concepts covered apply to coding agents in general.
The course can be delivered in either Italian or English, and can be held either in person or remotely.
Taking part in the course requires excellent programming skills and access to a frontier model, through a subscription or the API. For the modules on local models, participants need a suitable machine, such as a computer with a dedicated GPU or an Apple Silicon Mac with enough memory; the exercises can also be done with smaller models.
The planned modules, each lasting half a day (4 hours), are as follows:
- Fundamentals
- How a language model works: tokens, context window, temperature;
- Prompt caching and cost structure;
- Frontier models and open-weight models;
- Chat, completion, and agents;
- Model and harness
- Model and harness: what each one does and why both matter;
- An agent's work loop: reading, tools, editing, verification;
- Claude Code: sessions, operating modes, and permissions;
- Planning and subagents;
- Overview of alternative harnesses;
- Project context
- Instruction files (
CLAUDE.md,AGENTS.md); - Conventions written in a verifiable form;
- Documentation as current state, and a decision ledger;
- Project memories;
- Instruction files (
- Automated guardrails
- Hooks on the agent's work loop: checks at the end of a turn and before tool use;
- Formatters, linters, and tests as completion conditions;
- Checking architectural conventions, and documented exceptions;
- Permissions and sandboxes;
- The workflow
- Specification before code, and breaking work down into tasks;
- Discussing architectural choices;
- Reviewing generated diffs;
- Verification in the browser with Playwright;
- Commits and change history;
- Extending agents
- Model Context Protocol: using and developing an MCP server;
- Skills and custom commands;
- Specialized subagents for review and security;
- Working in parallel;
- Local models (part one)
- Use cases: data confidentiality, costs, offline use;
- Open-weight models and quantization;
- Hardware requirements: VRAM and unified memory;
- Runtimes: llama.cpp, LM Studio, Ollama, vLLM;
- Local models (part two)
- Compatible APIs and gateways (LiteLLM) to route requests between frontier models and local models;
- Using a local model with a frontier harness;
- Limits of local models: long contexts and complex tool calls;
- Building a test bench for comparing models;
- Security and privacy
- Data that ends up in prompts, in logs, and with providers;
- Secrets management;
- Prompt injection from external content: web pages, issues, dependencies;
- Least privilege, personal data, and GDPR;
- Company adoption policies;
- Measuring adoption
- Agent telemetry: tokens, costs, sessions, tools;
- Collecting and visualizing telemetry on self-hosted infrastructure;
- Useful metrics and misleading metrics;
- Integrating models into products (optional)
- Model APIs, tool use, and structured output;
- Document retrieval (RAG);
- MCP servers as an application's interface to agents;
- Evaluating responses;
- The team and the organization (optional)
- Responsibility for generated code;
- Review as part of a senior developer's work;
- Growth of junior developers;
- Gradual introduction into teams;
During the modules, preparatory exercises will be provided for learning the topics covered.