Skip to content

Impulsa IA

Curriculum

The 172 tasks of the path, spread across 6 levels.

Level 1 — AI fundamentals and prompting

20 tasks

Understanding generative AI

  1. N1-T01What are generative AI and large language models?
  2. N1-T02How a language model generates text: tokens and the context window
  3. N1-T03Capabilities and limits: hallucinations, knowledge cutoff, bias
  4. N1-T04Overview of AI assistants and introduction to Claude
  5. N1-T05Using AI responsibly: privacy and ethics

Prompting fundamentals

  1. N1-T06Anatomy of a good prompt
  2. N1-T07Providing context and a role
  3. N1-T08Writing clear and specific instructions
  4. N1-T09Guiding by example: few-shot prompting
  5. N1-T10Getting a structured output format

Intermediate techniques

  1. N1-T11Breaking down a complex task: prompt chaining
  2. N1-T12Getting the model to reason step by step
  3. N1-T13Structuring with XML tags and delimiters
  4. N1-T14Iterating on and refining a prompt
  5. N1-T15Evaluating response quality

Practical cases

  1. N1-T16Professional writing and rewriting
  2. N1-T17Summarizing and analyzing documents
  3. N1-T18Extracting data into tables or JSON
  4. N1-T19Building a library of reusable prompts
  5. N1-T20Final project: a prompt assistant for your profession

Level 2 — Claude Code and the command line

32 tasks

Getting started with Claude Code

  1. N2-T01Discovering Claude Code: a coding agent in your terminal
  2. N2-T02Installing Claude Code and signing in to your account
  3. N2-T03Terminal basics for working with Claude Code
  4. N2-T04Starting a first session and exploring an existing project
  5. N2-T05Understanding the agentic loop: explore, act, verify
  6. N2-T06Choosing the model with /model and managing context with /compact and /clear

Everyday work with Claude Code

  1. N2-T07Requesting code changes and reviewing diffs
  2. N2-T08Referencing files with @ and sharing images
  3. N2-T09Running shell commands from the session with the ! prefix
  4. N2-T10Resuming a conversation with --continue and --resume
  5. N2-T11Rolling back with checkpoints and /rewind
  6. N2-T12Workshop: fixing a bug end to end

Memory and configuration

  1. N2-T13Creating a CLAUDE.md file with /init
  2. N2-T14Organizing memory: user and project levels, and imports
  3. N2-T15Configuring settings.json: scopes and precedence
  4. N2-T16Environment variables and useful command-line flags
  5. N2-T17Customizing the experience: /config, status line and output styles
  6. N2-T18Creating custom slash commands

Permissions and plan mode

  1. N2-T19Understanding the permission system and the /permissions command
  2. N2-T20Permission modes: default, acceptEdits, plan and bypassPermissions
  3. N2-T21Planning before acting with plan mode
  4. N2-T22Writing allow, ask and deny rules for tools
  5. N2-T23Workshop: setting up a safe project configuration for a team

Git and development workflows

  1. N2-T24Creating commits and writing commit messages with Claude Code
  2. N2-T25Creating branches and pull requests with the gh CLI
  3. N2-T26Working in parallel with git worktrees
  4. N2-T27Writing tests first: TDD with Claude Code
  5. N2-T28Refactoring and documenting an existing codebase

Non-interactive mode and IDEs

  1. N2-T29Using headless mode with claude -p
  2. N2-T30Using JSON output in shell scripts
  3. N2-T31Using Claude Code in VS Code and JetBrains IDEs
  4. N2-T32Final project: shipping a complete feature with Claude Code

Level 3 — Tools and integrations

35 tasks

Understanding the Model Context Protocol

  1. N3-T01What is the Model Context Protocol (MCP)?
  2. N3-T02MCP architecture: clients, servers, tools, resources and prompts
  3. N3-T03MCP transports: stdio and HTTP
  4. N3-T04Adding an MCP server with claude mcp add
  5. N3-T05MCP server scopes and team sharing with .mcp.json

Using MCP servers

  1. N3-T06Authenticating a remote MCP server with OAuth via /mcp
  2. N3-T07Connecting MCP servers for files and the browser
  3. N3-T08Using MCP resources with @ mentions
  4. N3-T09Using MCP prompts as slash commands
  5. N3-T10Troubleshooting an unresponsive MCP server
  6. N3-T11Choosing trustworthy MCP servers

Building your own MCP server

  1. N3-T12Setting up an MCP server with the TypeScript SDK
  2. N3-T13Defining tools with input schemas
  3. N3-T14Exposing resources and prompts
  4. N3-T15Testing a server with MCP Inspector
  5. N3-T16Building an MCP server in Python
  6. N3-T17Workshop: an MCP server for your team's tools

The Claude API

  1. N3-T18First calls to the Messages API
  2. N3-T19Managing API keys securely
  3. N3-T20Letting Claude call your functions with tool use
  4. N3-T21Displaying responses in real time with streaming
  5. N3-T22Reducing cost and latency with prompt caching
  6. N3-T23Processing large volumes with the Message Batches API

GitHub and databases

  1. N3-T24Installing the GitHub app with /install-github-app
  2. N3-T25Automating reviews and fixes with Claude Code GitHub Actions
  3. N3-T26Mentioning @claude in issues and pull requests
  4. N3-T27Querying a PostgreSQL database through MCP
  5. N3-T28Generating and reviewing schema migrations
  6. N3-T29Workshop: analyzing SQL data with Claude

Automation

  1. N3-T30Automating repetitive tasks with headless scripts
  2. N3-T31Scheduling runs with cron and CI
  3. N3-T32Connecting your work tools through MCP servers
  4. N3-T33Building a document-processing pipeline
  5. N3-T34Logging and monitoring your automations
  6. N3-T35Final project: a complete Claude integration into your tools

Level 4 — Subagents and multi-agent orchestration

25 tasks

Understanding subagents

  1. N4-T01Why subagents: isolated context and specialization
  2. N4-T02Managing subagents with the /agents command
  3. N4-T03Writing a subagent file: frontmatter, description and system prompt
  4. N4-T04Restricting tools and choosing a subagent's model
  5. N4-T05Project subagents and user subagents

Designing useful subagents

  1. N4-T06Creating a code-reviewer subagent
  2. N4-T07Creating a debugging and test-analysis subagent
  3. N4-T08Creating a code and documentation research subagent
  4. N4-T09Delegating explicitly or letting Claude choose the subagent
  5. N4-T10Workshop: a team of three subagents for your project

Orchestration patterns

  1. N4-T11Orchestrator and workers: the delegation pattern
  2. N4-T12Parallelizing independent tasks
  3. N4-T13Chaining agents in a pipeline
  4. N4-T14Passing context and synthesizing results
  5. N4-T15Avoiding conflicts: worktrees and file ownership

The Claude Agent SDK

  1. N4-T16Discovering the Claude Agent SDK
  2. N4-T17Building a first agent with the SDK in TypeScript or Python
  3. N4-T18Adding custom tools and MCP servers to an SDK agent
  4. N4-T19Defining subagents programmatically
  5. N4-T20Managing permissions and sessions in the SDK

Observing, evaluating and debugging

  1. N4-T21Observing agent work: logs and transcripts
  2. N4-T22Diagnosing coordination failures between agents
  3. N4-T23Controlling token usage in a multi-agent system
  4. N4-T24Workshop: comparing a single agent with a team of agents
  5. N4-T25Final project: a multi-agent system for a real workflow

Level 5 — Skills, hooks, permissions and security

35 tasks

Agent Skills

  1. N5-T01What is a skill? Instructions loaded on demand
  2. N5-T02Skill structure: SKILL.md, frontmatter and supporting files
  3. N5-T03Writing a description that triggers the skill at the right time
  4. N5-T04Adding scripts and resources to a skill
  5. N5-T05Personal skills, project skills and shared skills
  6. N5-T06Workshop: creating a skill for one of your team's processes

Hooks

  1. N5-T07Understanding hooks and their events
  2. N5-T08Configuring a hook with /hooks and settings.json
  3. N5-T09PreToolUse: validating or blocking an action before it runs
  4. N5-T10PostToolUse: formatting and checking code automatically
  5. N5-T11Lifecycle hooks: SessionStart, Stop and Notification
  6. N5-T12Securing and debugging your hooks

Plugins

  1. N5-T13What is a Claude Code plugin?
  2. N5-T14Installing plugins from a marketplace with /plugin
  3. N5-T15Packaging commands, subagents, skills and hooks into a plugin
  4. N5-T16Creating and sharing a team marketplace
  5. N5-T17Governing plugin use across an organization

Advanced permissions and sandboxing

  1. N5-T18Applying the principle of least privilege to agents
  2. N5-T19Fine-grained permission rules for Bash, Read, Edit and WebFetch
  3. N5-T20Enforcing policy with managed settings
  4. N5-T21Isolating execution: sandboxing, containers and devcontainers
  5. N5-T22Controlling network and working-directory access
  6. N5-T23Workshop: hardening a project's configuration

Prompt injection and secret protection

  1. N5-T24Understanding direct and indirect prompt injection
  2. N5-T25Recognizing untrusted content: web, files and tool output
  3. N5-T26Defending against injection: isolation, validation and human confirmation
  4. N5-T27Protecting secrets: .env files, deny rules and environment variables
  5. N5-T28Detecting and revoking an exposed secret
  6. N5-T29Assessing the risks of third-party MCP servers

Code review and security

  1. N5-T30Systematically reviewing AI-generated code
  2. N5-T31Running a security review with /security-review
  3. N5-T32Integrating static analysis and security tests into CI
  4. N5-T33Tracing and auditing agent activity
  5. N5-T34Writing an AI usage policy for your team
  6. N5-T35Final project: a secure, well-equipped Claude Code environment

Level 6 — Autonomy: long-running agents and deployment

25 tasks

Planning long tasks

  1. N6-T01Autonomous agents: definition, benefits and limits
  2. N6-T02Writing a specification before launching the agent
  3. N6-T03Breaking a project into verifiable steps
  4. N6-T04Tracking progress with to-do lists and progress files
  5. N6-T05Managing context over a long session: compaction and persistent notes

Long-running agents

  1. N6-T06Running agents in the background and in parallel
  2. N6-T07Building an agentic loop with the Claude Agent SDK
  3. N6-T08Resuming an interrupted session without losing work
  4. N6-T09Handling errors, retries and human checkpoints
  5. N6-T10Workshop: an agent that moves a repository forward autonomously

Evaluating agents

  1. N6-T11Defining measurable success criteria
  2. N6-T12Building a set of evaluation cases
  3. N6-T13Using a model as a grader
  4. N6-T14Workshop: comparing prompts, models and configurations
  5. N6-T15Detecting regressions over time

Deploying agents

  1. N6-T16Running Claude Code in CI/CD with GitHub Actions
  2. N6-T17Deploying an SDK agent in a container
  3. N6-T18Managing configuration, secrets and identities in production
  4. N6-T19Monitoring costs, logs and performance
  5. N6-T20Securing an agent exposed to users

Capstone project

  1. N6-T21Choosing and scoping your final project
  2. N6-T22Designing your agent's architecture
  3. N6-T23Building and iterating with evaluations
  4. N6-T24Preparing for production and documentation
  5. N6-T25Final project: designing, evaluating and deploying an autonomous agent