Contract with an agent. CLAUDE.md as your permanent signature.

You're already using AI as a chat — you ask a question, get an answer, and copy it into your work. This module starts at a crossroads: next to chat, a different category has emerged — an agent, who doesn't answer, but acts. First, we'll figure out how they differ and why this changes your work — and at the end, you'll write your first CLAUDE.md and test it hands-on.

Chat and agent. Two different tools.

You already know chat — that's ChatGPT or Claude.ai in your browser. You type a question — you get an answer. Whatever's useful, you manually copy into your work. Chat is a conversationalist

: smart, but "behind glass." It doesn't snoop in your files and knows nothing about your project until you tell it again.A second category has emerged next to it — an agentacts on its own: it opens your files, edits them, runs commands in the terminal, looks at the result, and moves on. It doesn't just "suggest what to type"; it does it and shows you what happened. This is no longer just a conversational partner, but an executor with hands.

2024 vs 2026. The same bug — two worlds.

Further in this module: how an agent works internally, a "before and after" demo on a real group, and your first CLAUDE.md — at the user level and in the project — to stop explaining to the agent every session who you are and for whom you are writing code.

How an agent does this. A cycle of actions.

You've already understood the difference: chat answers, an agent acts. Now — how exactly it acts so that it doesn't look like magic.

Inside — a cycle of actions, not just one reply. You write the task. The agent decides "first I'll read the file" - and reads it. Sees the content, thinks further: "now I'll edit" - and edits. Then it runs the tests itself. And so on in a loop, until the task is closed or it runs into a question for you.

Each downward arrow is a new model call. On large tasks, there are dozens of them. You see this as a semi-transparent stream in the TUI: Reading src/auth.py, Editing tests/test_login.py, Running pytest.

Where to run it

Claude Code is not tied to one window. The same setup (your CLAUDE.md) works in the terminal, in the editor, and in the browser. You choose where it's more convenient for the task.

MarsCode — our agent

MarsCode — our own tool in the same category as Claude Code. It goes to models via Mars, so for you free — The school issues the balance. One thing is important for you here: you don't need to pay for the models.

In this course, we'll be learning with Claude Code — everything works “out of the box” with it, and there's full documentation. We'll connect MarsCode in Module 5 when we start building our own Skills and saving costs.

Codex (OpenAI) and Antigravity (Google) — same thing, different vendors. We won't touch them in this course; if a student asks, it's just another agent, but from a different company.

Demo. Without CLAUDE.md and with it.

Case Study: Mentor Zukhra, Yunusobod location, Python 7-9 years old group, 6 children. She opens Claude Code in the repo with starter projects. She asks for the same thing. First without a contract, then with one.

$ cd ~/mars-lessons/python-7-9 && claude# agent starts from scratch

> help me add another game
  about math for my students

Claude: I'm ready to help. A couple
of questions to understand the context:

  1. What is the age of the students?
  2. In what language should the explanations
     be in the comments?
  3. Which libraries are allowed?
  4. How detailed should the
     comments be?
  5. Is OOP allowed or a procedural
     style?

# 3 minutes of ping-pong in each session.

$ cd ~/mars-lessons/python-7-9 && claude# agent automatically reads ./CLAUDE.md

> help me add another game
  about math for my students

Claude: I'll create a starter
“Guess the Number” in the project style:

  • pygame + random, no f-strings
  • variables in Russian-Latin script
  • a comment for every 2 lines
  • a short header “What this
    program does”

  I read 01-circle.py for style.
  Creating 06-guess-number.py.

Edit: 06-guess-number.py (+38)
Bash: python3 -m py_compile ✓

# 40 seconds to result.

Project CLAUDE.md for Python 7-9 years old group

Here's the file that's in Zukhra's repo. Copy it as a starter — it's one of three ready-made pre-build templates:

./CLAUDE.md · mars-lessons/python-7-9# Mars IT School — Python for 7-9 years old group
# Yunusobod location, mentor Zukhra

## Who reads this code
- Children 7-9 years old, four of whom are seeing programming for the first time.
- Language of explanations: Russian. Uzbek Latin script is allowed
  in variable names if it helps (`tugma` instead of `button`).
- Terminology: do not use "function", "class", "loop"
  without explanation through an everyday analogy in the comment.

## Code Conventions
- **Every line is commented in Russian.** This is not code for production,
  this is code for a lesson.
- Variable names — simple words or transliteration (`schyot`, not `score_counter`).
- Only `pygame` and `random`. Do not use f-strings,
  list comprehensions, dataclasses.
- The file always starts with a short comment
  “What this program does” on 1 line.

## Workflow
- Each file must be run via `python3 file.py` without arguments.
- Before commit — `python3 -m py_compile file.py` (syntax check).
- Do not edit `.solutions/` — it contains ready solutions for subsequent groups.

Different mentor — different contract

The same template “who reads / conventions / workflow” — but a different audience. Timur, Chilonzor location, second year Python, preparing Olympiad participants 12-14. Compare with Zukhra's:

./CLAUDE.md · mars-lessons/python-olymp-12-14# Mars IT School — Python Olympiad for 12-14 years old group
# Chilonzor location, mentor Timur

## Who reads this code
- Children 12-14, second year Python, preparing for the Republican
  Olympiad in Informatics.
- Language of explanations: Russian. Variable names — English
  (the Olympiad is in English, no point in teaching otherwise).
- Know: functions, loops, dictionaries, generators.
  DO NOT know: classes, dataclasses, async.

## Code Conventions
- Full typing: `def solve(n: int) -> list[int]:` — we teach
  to read signatures.
- Complex algorithms — definitely `doctest` or `assert`
   with an example from the problem statement.
- The solution must pass tests in `./tests/` (`pytest`).
- Each file starts with a docstring: problem, constraints,
  time/memory complexity.
- DO NOT use third-party libraries except `math`, `collections`,
  `itertools`, `heapq`, `bisect` — Olympiad set.

## Workflow
- Before commit — `pytest -q` (all green).
- Solutions in `./solutions/`, tests in `./tests/`.

For Zukhra — prohibition of typing and list comprehensions, for Timur — mandatory typing. One template, two different contracts. The third template — Shahzod, Sergeli, React/TypeScript 15-17 — is located nearby in the file starters.md. Take one as an example and adapt it to your group.

The two files you need. User and project.

CLAUDE.md lives on two levels, and for getting started, you need exactly these two. Both are loaded automatically at the beginning of each session — no need to explain again.

There are two more levels you can skip for now: managed (a rule for the whole school, set by IT — it's empty for us right now) and local (./CLAUDE.local.md — personal notes on the project, in .gitignore). You'll need them later — not today.

Claude also takes notes himself

Besides your CLAUDE.md, the agent itself records what it noticed along the way: which commands build the project, where there were bugs, what patterns are in your code. The command /memory shows all memory files and lets you open them. This is a supplement, not a replacement: CLAUDE.md — what manually you want it to always know; auto-memory — what it itself understood and remembered.

Exercise. Try it today, 30 minutes.

Four parts. Do it manually in the terminal, don't just read it as theory. After this, you'll have a working user+project CLAUDE.md pair and a verified /memory.

~/.claude/CLAUDE.md# About me
I am a mentor at Mars IT School, point <X>,
leading <stack> for age group <Y>.
Working language: Russian. English for technical terms.

# Agent Workflow Style
- Explain your plan to me before editing files
  (use plan mode when appropriate)
- If you're unsure about an API/library — ask, don't invent
- When writing code that will go to children —
  short lines, simple names, comments in Russian
- Always show git diff before committing, don't commit yourself

# What I usually do
- Prepare starter projects for lessons
- Check students' code
- Write internal scripts for Mars

Quiz. Check what stuck.

What's next. Module 4 — context engineering.

You now have a permanent signature — the agent in any Mars project knows who you are and who you're writing for. The next mandatory module is the fourth (modules 2-3 come after feedback): about working memory and context engineering. What is /compact, why the agent "gets dumber" towards the evening of a long session, how to use sub-agents as a way to isolate context. This is the module for which the course exists.

Modules 2-3 (Delegation × NTP, Description × Knowledge) and Module 5 (your own Sub-agents and Agent Skills) — after pilot feedback from the first mentors.