AI doesn't invent books. It predicts the next token.

Before deciding whether to “give it to AI or do it myself” — you need to understand how it even assembles an answer. One mechanism: predict the next token based on what came before. Everything follows from this — where it's strong, where it confidently lies, and which tasks you can delegate to it unsupervised.

Hook — about books that don't exist.Mavjud bo'lmagan kitoblar haqida

Mental model — NTP, how an agent constructs an answer.NTP — agent javobni qanday yig'adi

In the last module, you gave the agent a contract. Now, let's look at how it actually writes an answer: this directly determines what you can trust it with, and what you'll need to check manually.

1. AI doesn't search for an answer — it completes it

2. How it works inside — simply put

Imagine a game: you take 5 of your SMS messages, count which word most often follows which, and then use this frequency table to write a new “message.” An LLM does exactly this — only instead of a small table, it has billions of parameters, trained on a massive corpus of text.

The main shift. When the agent writes “collection of poems "Bakhor" 1953” — it didn't retrieve this fact from memory. It generated it token by token, and each token was “plausible in form.” “Bakhor” is a normal Uzbek word. 1953 is a normal year. This is a valid continuation statistically. Whether such a collection exists in reality — for NTP, that's not a question of mechanism.

3. The model is an “internet archive,” not a database

A good metaphor from Andrej Karpathy: the model is a lossy zip archive of the internet. Not an index, not a database — an archive. When you "ask her about Zulfiya," you're not searching for a record — you're making the archive unpack something plausible. Frequent and popular is unpacked clearly. Rare is reconstructed from neighboring scraps: sounds right, but there's no specifics there.

Andrej Karpathy · «How I Use LLMs» · 2025

4. Well-worn paths vs novel territory

is a project to create a self-improving AI agent. ## CLAUDE.md The main agent is Claude. He is the "brain" of the project. He is responsible for the overall strategy, task decomposition, and code generation. ## AGENTS.md This file describes the structure of the agents and their interaction. ### Main Agent The main agent is Claude. He receives the initial prompt and breaks it down into sub-tasks. For each sub-task, he creates a sub-agent. ### Sub-Agents Sub-agents are specialized agents that perform specific tasks. For example, a sub-agent can be responsible for: * **Code generation:** Generates code based on the task description. * **Testing:** Writes tests for the generated code. * **Debugging:** Finds and fixes errors in the code. * **Documentation:** Writes documentation for the code. Each sub-agent receives its own context and prompt. It can also create its own sub-agents if necessary. ### Interaction Agents interact with each other through a shared context. The main agent monitors the progress of sub-agents and provides feedback. ## Claude Code This is the code that Claude generates. It is stored in the `claude_code` directory. ## MarsCode This is the code that Mars generates. It is stored in the `marscode` directory. ## How to run 1. Clone the repository: `git clone https://github.com/user/project.git` 2. Install dependencies: `pip install -r requirements.txt` 3. Run the main agent: `python main.py` ## Example Let's say we want to create a web application. 1. **Main agent (Claude):** Receives the prompt "Create a web application for managing tasks." 2. **Claude:** Breaks down the task into sub-tasks: * Create a database schema. * Create a backend API. * Create a frontend interface. 3. **Claude:** Creates sub-agents for each sub-task. * **Sub-agent 1 (Database):** Receives the prompt "Create a database schema for tasks (id, title, description, status)." * **Sub-agent 2 (Backend):** Receives the prompt "Create a backend API for CRUD operations on tasks." * **Sub-agent 3 (Frontend):** Receives the prompt "Create a frontend interface for displaying and managing tasks." 4. **Sub-agent 1 (Database):** Generates SQL code for the database schema. 5. **Sub-agent 2 (Backend):** Generates Python code for the backend API. 6. **Sub-agent 3 (Frontend):** Generates HTML, CSS, and JavaScript code for the frontend. 7. **Main agent (Claude):** Monitors the progress of sub-agents, provides feedback, and integrates the generated code. ## Terminal The terminal is used for interacting with the agents. You can send commands to agents and view their output. ## Context The context is a shared memory that agents use to store information. It contains: * Task description * Generated code * Test results * Debugging information * Documentation ## Prompt The prompt is a natural language instruction that is given to an agent. It describes the task that the agent needs to perform. ## Future plans * Implement self-improvement mechanisms. * Add support for more programming languages. * Integrate with external tools (e.g., IDEs, version control systems). * Improve agent communication and collaboration. scale, not "yes/no. On the left are tasks the model has seen a million times. On the right is where it's treading on thin ice and doesn't even know it.

5. Smooth text knows how to hide a guess

From here, a bridge to Delegation. If you understood CLAUDE.md and AGENTS.md, you're ready to start writing Claude Code. The simplest way to start is to write a single agent. An agent is a file, usually a Markdown file, that contains a prompt for Claude. For example, you could create a file named `hello.md` with the following content: ```markdown Hello, Claude! ``` To run this agent, you would use the `mars` command: ```bash mars hello.md ``` This would send the content of `hello.md` to Claude, and Claude would respond. The response would be printed to your terminal. Now, let's make it a bit more interesting. Let's create an agent that asks Claude to write a short story. Create a file named `story_writer.md` with the following content: ```markdown You are a renowned author. Write a captivating short story about a brave knight and a mischievous dragon. ``` Run it: ```bash mars story_writer.md ``` Claude will then generate a story for you. ### Sub-Agents: Breaking Down Complex Tasks For more complex tasks, you'll want to break them down into smaller, manageable pieces. This is where sub-agents come in. A sub-agent is essentially another agent that is called by a parent agent. Let's say you want to create a website. You could have a main agent that orchestrates the entire process, and then sub-agents for specific tasks like generating HTML, CSS, and JavaScript. Here's an example of how you might structure this. First, create a main agent file, let's call it `website_builder.md`: ```markdown You are a web development expert. Your task is to build a simple static website. First, generate the HTML structure. {{call html_generator.md}} Next, generate the CSS styling. {{call css_generator.md}} Finally, generate any necessary JavaScript. {{call js_generator.md}} ``` Notice the `{{call ...}}` syntax. This is how you invoke a sub-agent. When `website_builder.md` is run, it will first execute `html_generator.md`, then `css_generator.md`, and finally `js_generator.md`. The output of each sub-agent will be included in the context of the subsequent agents. Now, let's create the sub-agent files: **`html_generator.md`**: ```markdown Generate the basic HTML structure for a simple webpage with a header, a main content area, and a footer. ``` **`css_generator.md`**: ```markdown Based on the HTML provided, generate some basic CSS to style the webpage. Use a clean, modern design. ``` **`js_generator.md`**: ```markdown Generate a small JavaScript snippet that adds a simple alert when the page loads. ``` To run the entire process, you would simply run the main agent: ```bash mars website_builder.md ``` Claude will then generate the HTML, CSS, and JavaScript, combining them into a complete website structure. ### Context and Prompts Each agent and sub-agent operates within a specific context. The context includes: * **The prompt of the current agent:** This is the content of the Markdown file itself. * **The output of previous agents/sub-agents:** When you use `{{call ...}}`, the output of the called sub-agent is appended to the context for the next steps. * **Any additional context provided via the `mars` command:** You can pass additional context using the `-c` or `--context` flag. For example, if you wanted to provide some specific requirements for the story writer, you could do this: ```bash mars story_writer.md -c "The knight's name is Sir Reginald and the dragon is named Sparky. Sparky is not evil, just misunderstood." ``` This additional context would be included in the prompt sent to Claude. ### MarsCode: A Powerful Tool MarsCode is designed to make working with Claude more efficient and organized. By breaking down complex tasks into smaller, modular agents, you can: * **Improve clarity:** Each agent has a clear, focused purpose. * **Enhance reusability:** You can reuse sub-agents across different projects. * **Simplify debugging:** If something goes wrong, it's easier to pinpoint the problematic agent. * **Iterate faster:** You can quickly experiment with different prompts and agent configurations. Keep exploring, and you'll soon discover the full power of MarsCode! How the agent collects the answer — you understand, How to check it. Which means you can consciously decide: what to give to the agent entirely, what to do together, and what to do only under your control. This is the first D — delegation.

4D · Delegation — what to give, what to leave.Nimani berasan, nimani o'zing qilasan

The first of four operator skills is delegation: decide “do it myself / with an agent / give it to an agent”. Next, we'll look at the three parts of this decision and three practical levels for a Mars mentor.

Three parts of one decision

Three levels of delegation for a mentor (how to apply)

We take sub-component 03 (Task Delegation) and break it down into three practical levels. This isn't abstract — this is how you'll label your list of 10 tasks in the exercise.

Integration with NTP. The level is not chosen randomly. Full — when the task is in well-worn paths and there's a verifiable check (diff, test). Co-creation — when the task requires your pedagogical judgment (this is no longer well-worn). Validation — when the task is in novel territory (your lesson, your specifics), but the agent can help as an extra pair of eyes — provided you filter afterwards.

Demo — one day of Zukhra in Claude Code.Zuhraning bir kunlik ish kuni

Zukhra, a Python mentor in Yunusabad. Group 7-9 years old (Mars Python juniors). Today — 4 different tasks in the morning. Each falls into its own level of delegation. On the last one — NTP fails; see how exactly she catches it.

10:14 · Full delegation — translating an announcement for parents

Tomorrow is a trip to the park, need to send an announcement to parents in Uzbek. A well-known Claude well-worn path: standard constructions, millions of examples in the corpus.

$ claude
✓ CLAUDE.md loaded  ~/mars/comms/CLAUDE.md (1,420 tokens)

› translate to Uzbek for parents, polite tone, no emojis:
  "Tomorrow, Saturday at 10:00 AM, departure to Tashkent Park. Gathering at the Yunusabad branch.
  We will return by 1:00 PM. Please bring water and a cap. If your child
  is not attending — please notify us by 6:00 PM today."

⠋ Generating…

Hurmatli ota-onalar,

Ertaga, shanba kuni soat 10:00 da Tashkent Parkga sayohat
qilamiz. Yig'ilish — Yunusobod filiali oldida. Soat 13:00 ga
qaytamiz. Iltimos, farzandingiz uchun suv va shapka olib keling.

Agar farzandingiz bormaydigan bo'lsa, iltimos, bugun soat 18:00
gacha xabar bering.

Hurmat bilan,
Mars IT School · Yunusobod

What happened: a well-worn path in its purest form — translation between paired languages. Zukhra checks it with her eyes for 30 seconds, then sends it. Level — Full. Diff = text, verifiable = an Uzbek parent understands it at a glance.

10:18 · Co-creation — 5 loop assignments for the 12-14 group

Zukhra sometimes substitutes for a colleague in the older group. She's preparing a block "introduction to for and while».

› come up with 5 loop assignments (for/while) for a Python group aged 12-14.
  level: they know variables, if/else, input. loops — first time.
  each assignment: title, goal, code skeleton with TODO for the child,
  expected output. increasing difficulty.

⠋ Drafting…

1. "Counting Game from 1 to N"  — for, range, print
2. "Sum from 1 to N"      — for loop, accumulator
3. "Guess the Number"         — while, input, break
4. "Multiplication Table"    — nested for
5. "Sieve of Eratosthenes"  — list, for, modulo
   + code skeletons for each task

What Zukhra does. She opens each skeleton. Task 5 (Eratosthenes) is too complex for a first introduction to loops, so she removes it. Task 2 she renames to "piggy bank" (the metaphor is clearer). Task 3 — the agent in while doesn't have "attempts" — she adds a counter. Then she asks to finalize the remaining 4 into .py files.

What happened: The well-worn path for the framework (Python boilerplate, standard tutorials) is there, but the pedagogical decision "what suits this age group" — that's Zukhra. Level — Co-creation. Without her filter, the 5th task would have gone to the kids and ruined the lesson.

10:25 · Validation — lesson plan check

Tomorrow is the "lists" lesson for the Python 7-9 group. She wrote the plan yesterday and wants a second pair of eyes: did she get anything wrong in the Python facts, did she overload the age group.

› read lesson-08-lists.md. find:
  (a) factual errors about Python — syntax, behavior;
  (b) places where the code is more complex than the lesson's topic (we're only doing lists);
  (c) parts where the variable name isn't as in CLAUDE.md (snake_case, Russian words — okay).
  DO NOT edit the file. provide a list with quotes.

⠋ Reading lesson-08-lists.md…
⠋ Reading CLAUDE.md…

Found:
[a-1] line 47: "fruits.append() returns a new list"
       — this is incorrect. append() modifies on the spot
       and returns None.
[a-2] line 89: "the slice fruits[1:-1] excludes the last and
       second-to-last" — incorrect. It only excludes the last.
[b-1] line 112: example uses list comprehension
       — more complex than the lesson's topic, postpone.
[c-1] line 64: variable fruitList
       — camelCase, CLAUDE.md requires snake_case.
[a-3] line 134: "len() for a string also works via
       __length__" — this is __len__ (one underscore on each
       side would be __len__, incorrectly written).

Zukhra doesn't take things at face value. She opens lines 47, 89, 134 — three factual errors are confirmed based on her experience. Okay. Line 64 — its camelCase, definitely needed. Line 112 — agrees.

BUT. Zukhra remembers NTP. She asks the agent for a second pass:

› for each error found [a-1..a-3] quote the exact line from
  my file and from the official Python docs (section and URL).
  if you don't remember the URL — write "URL: not sure" instead of guessing.

⠋ Re-reading lesson-08-lists.md…

[a-1] my file line 47: «fruits.append(x) → returns [...x]»
       Python docs: data structures · list.append() →
       URL: not sure (I remember it's in "More on Lists")
[a-2] my file line 89: «fruits[1:-1] excludes the last
       and second to last»
       Python docs: tutorial · sequence slicing →
       URL: not sure
[a-3] Line 134 in the file — NO mention of __length__.
       I made a mistake in the first answer. My apologies,
       line 134 — it's an example of range(len(fruits)), not __len__.

There it is. The third "error" (__length__) — was an agent hallucination. Quotes from the file for the first two were found (that's true). For the third, the agent admitted when pressed for the source. Level — Validation. Zukhra used the agent as an "extra pair of eyes," but the final filtering was hers.

10:31 · Novel territory — essay about Zulfiya

That very task from the hook. Zukhra tried it — smooth text, 5 collection titles. Right in Claude Code:

› write an essay about the Uzbek poetess Zulfiya for the cultural
  section of the school newspaper. 800 words. for children 12-14. mention 3-4
  of her main poetry collections with years.

⠋ Generating 800 words…

Zulfiya Israilova (1915–1996) — the voice of Uzbek poetry of the XX...
[...]
her collections include:
  • «Hayot varaqlari» (1932)
  • «Qizlar qo'shig'i» (1947)
  • «Bahor nafasi» (1953)
  • «Onamning kuylari» (1968)
  • «Xotira» (1985)
[...]

Zukhra catches the hallucination in two moves.

1. She asks for a source for each title: «for each collection, provide: library catalog or URL. if not sure — write "not sure"». The agent returns: «Hayot varaqlari — available in Alisher Navoi catalog; Qizlar qo'shig'i — available; Bahor nafasi — not sure; Onamning kuylari — not sure; Xotira — available».
2. She checks the 5 titles in the catalog natlib.uz (National Library of Uzbekistan). 3 are found, 2 are not. This matches what the agent admitted.

What happened. This is not Validation, this is novel territory without a source in the context. NTP confidently generated 5 plausible names, because "the name of a collection by a mid-20th century Uzbek poetess" is a valid combination of words in terms of form. Of these, 3 are true, 2 are fabricated. Smooth prose wrapped a guess.

A lesson for Zukhra (and for you): when a task involves specific facts in a narrow domain (names, dates, titles, quotes) — don't delegate full. Either give the agent a source (upload a catalog / Wikipedia / PDF), or write the facts yourself, and let the agent just wrap them in text for the target audience.

› read student-solution.py. check:
  (1) correctness — are there logical errors;
  (2) complexity — estimate O(?) and compare with expected O(n);
  (3) compliance with CLAUDE.md (O(...) comment at the top, snake_case).

[1] correctness:
  on line 34, in the check prefix[j] - prefix[i] == K
  logically correct. But the loop on lines 28-40 — a double for loop,
  this is O(n²), not O(n).
[2] complexity:
  actually O(n²). Expected for prefix sums — O(n) via
  hashmap "have we seen prefix[j]-K before".
[3] CLAUDE.md:
  the comment "# O(...)" at the top is missing.
  variables prefSum, nMax — camelCase.
[reference] in this repo there are similar solutions:
  olymp/easy/sum-subarray.py — O(n) via dict.
  olymp/medium/two-sum.py — the same pattern.

Exercise — 3 probes for your own tasks.Uchta probe — o'z vazifalaringga

This is a test to check your skills on your real tasks. It won't get done by itself: set aside 20-25 minutes.

Quiz — check yourself in 3 minutes.O'zingni sina — 3 daqiqada

Three apply-questions. Not "recall the definition," but "apply to the situation." If you get even one wrong, go back to the corresponding section.

What's next — Module 3.Keyingisi — Modul 3