Build your ideas without writing code

You can use Claude Code in the Claude app, VS Code, the terminal, a browser, and on your phone. We will look at how these options differ and choose one environment where you will work for the rest of the course. The others can wait until a task actually requires them.

How a language model forms responses, how an agent differs from chat, and how to manage context in Claude Code.

One session's history ends, but work on the project continues. In this module, you will organize the project's rules, knowledge, and current state so that a new session can quickly understand what is happening and where to pick up.

A stronger model, high effort, and autonomous mode solve different problems. In this module you will learn to understand what exactly is worth changing for a specific task — and when it is better not to touch the settings at all.

The quality of Claude's work depends not only on the model. Context, instructions, skills, tools, memory, the organization of the work, and the ways of checking it together form the system this model works in.

A skill stores a recurring procedure, reference material, or working standard and loads it only when it is needed. In this module, you will create a skill for your project, learn to test it separately from the current session, and understand how to find and evaluate ready-made skills from other authors.

How to build acceptance of the work so it holds outside your own head: a criterion, evidence and someone to check. The tool is chosen after those three, not instead of them.

As long as Claude works inside the project, the worst mistake costs one rollback. An external service changes the cost: an email has already been read, a task has already been updated, a post has already been published. This module is about when connecting a service is actually necessary, how to give it the minimum required permissions, and and how to determine the recovery boundary in advance if it makes a mistake.

A hook connects an event in Claude Code to an automatic action. Claude has started or continued a session, is about to use a tool, has already performed an action, or is finishing the current turn — at that moment, you can automatically run a check, a command, or a tool from a connected service. In this module, you will configure your first hook and learn to design more complex automatic reactions without having to write technical files manually.

With a subscription, the meter is not running for every request, so it seems there is nothing to save. But there is a limited resource: the amount of work included in the plan and the time until it resets. This module is about the subscription boundary, how limits work, the factors that affect usage, and the decision you make when there is work left but the quota has run out.

One session stops being enough not when a task is complex, but when it acquires a structure: parts, dependencies between them, and points where the results have to come together again. Orchestration starts not with the number of agents, but with deciding which work depends on which, what can genuinely be done at the same time, and where several workers have to join back up.

A plugin adds a set of capabilities to Claude Code at once: skills, assistants, hooks, MCP integrations, and tools for working with code. The fact that it is installed says almost nothing about its usefulness—it is more important to understand exactly what the plugin adds, what problem it should solve, and whether Claude's behavior changed after installation. In this module, you will learn to look inside an extension before installing it, test it on a real task, and take a separate look at LSP—a plugin that changes how Claude works with code.

How to hand Claude work that runs without you: on a schedule, on an event, in the background. And how to make sure it was actually done, not merely started.

This is the last module of the course, and it is about the only problem left: everything is built correctly, and the result is still wrong. The check passes because the criterion changed along the way. The context is poisoned, and the reviewer repeats the worker's mistake. So many mechanisms have accumulated that no one can say anymore which one is there for what. We will examine four failure modes, and at the end we will assemble both of your course projects into a single system and look at it as a whole.

The hardest part of Claude Code is not writing a skill, but understanding whether the task requires a skill at all, rather than a hook, rule, connection, or schedule. Two or three questions, and you get one mechanism and the number of the module where it is covered.

Everything you return to, all in one place.

The documentation explains what the tool can do and what tasks it is intended for. Practice reveals the cost, limitations, and cases where a technique does not pay off. What follows is not a list of what is “right” and “wrong,” but guidelines worth testing on your own tasks.

Each term is explained where it first appears. Here they are collected together, in alphabetical order, with the module where the concept is covered in full.