It’s people management under a different name
What it is
Replace the word “agent” with “new employee” and reread the 7 principles: nothing feels strange to someone who has already led others. Intention describes the role; context is onboarding; data is the official system; criteria are goals; autonomy is the scope of authority; observation is the report; supervision is the 1:1 meeting. The report on “the new era of AI” gave a new name to old practices.
Why learn
People who think managing agents means learning everything from scratch get stuck before they even start. Realizing you already know a good part of the method removes fear and speeds up your first delegation. And it gives you a simple test: if you wouldn’t delegate like that to a person, don’t delegate like that to an AI.
Key concepts
Goal: translate one of your “people management” tasks into “agent management”.
Task: <a task you want to delegate>
1. Intention (role): why does this function exist? <response>
2. Context (onboarding): what would I explain on Day 1? <response>
3. Data (official system): where is the information that matters? <response>
4. Criteria (target): what does “done well” look like? <response>
5. Autonomy (delegation scope): how far should it decide on its own? <response>
6. Observation (report): what do I want to see, and when? <response>
7. Supervision (1:1): when do I review and correct? <response>
How to check: if any line is left blank, that’s exactly where the agent will make mistakes.
✓ Do this
✓ Ask “how would I do this with a new employee?” before writing any instruction.
✗ Avoid this mistake
✗ Treat agent management like a technical topic that only programmers understand.
Practice before you reveal
Take an employee or colleague you’ve already guided and list what you told them in the first week. Mark which principle each item corresponds to.
View commented answer
Usually, you find the house rules (context), where to look for information (data), and what they can decide on their own (autonomy). What’s often missing is the written criterion, because with people it gets adjusted in conversation. With an agent, it needs to be in the role.
What the agent doesn’t “figure out on its own”
What it is
A new employee infers a lot: they observe coworkers, notice the company tone, and ask in the hallway. The agent doesn’t do any of that; it works only with what’s written in the instructions and the data it has access to. Everything a person would infer has to become text: the tone, the source that counts, what to do when information is missing, and when to stop.
Why learn
Most agent mistakes come from what “seemed obvious” to the person who delegated. With a person, lack of clarity costs a lot by going slowly; with an agent, it costs immediately and at scale. Listing the implicit is the cheapest way to avoid this mistake.
Key concepts
Goal: turn the “obvious” into written instructions.
Paste at the end of your instruction and fill in:
- Tone with the client: <e.g., next, no slang, no emojis>
- Source that matters: <e.g., 2026 Agenda spreadsheet, Confirmed tab>
- Not allowed: <e.g., old WhatsApp messages>
- If information is missing: “don’t make it up; write [MISSING DATA] and tell me”
- Stop and call me when: <e.g., the client complains or talks about canceling>
How to check: ask the agent, “before you start, confirm in 3 lines what you understood”; if it doesn’t cite the source and the “if something is missing” rule, the instruction is still incomplete.
From concept to action
- What you know: identify the initial condition.
- What’s obvious: apply the described decision.
- What’s written: check the effect in the example.
- What the agent uses: record the output evidence.
✓ Do this
✓ Write the rule “if information is missing” in every instruction, even if it seems like an exaggeration.
✗ Avoid this mistake
✗ Assume the agent will notice the right tone or the correct source “from context”.
Practice before you reveal
List three things that anyone on your team knows without anyone saying them. Rewrite each one as an instruction sentence.
View commented answer
Example: “nobody responds to customers after 8pm” becomes “don’t send messages after 8pm; leave them as a draft for the morning”. The exercise shows how much of the operation depends on rules that are never written down.
People who program with agents already live this.
What it is
Code agents, like Claude Code and Codex, are AI programs that work inside a repository—the folder of a project with all its history. Anyone who uses these agents practices the 7 principles every day: the plan mode (the agent proposes before changing anything), the CLAUDE.md or AGENTS.md (a file with the project rules), the repository as the source, tests (automated checks), permissions, failure log, and review.
Why learn
This shows the method isn’t stage theory: it already works in production, in the hands of thousands of people. Even those who don’t program benefit by copying these practices into other areas. And programmers gain a vocabulary to explain their own routine to managers.
Key concepts
Goal: see the 7 principles in practice for a code agent.
1 Intention → plan mode: “propose the plan before changing files”
2 Context → CLAUDE.md / AGENTS.md at the root of the project
3 Data → “read the file before asserting something about it”
4 Criteria → “it’s only ready when <test command> passes”
5 Autonomy → permission mode: plan, default, acceptEdits
6 Observation → FALHAS.md: date, what broke, smallest fix
7 Supervision → code review before publishing
How to check: for each line, ask what the equivalent is in your area (e.g., FALHAS.md becomes a support errors spreadsheet).
✓ Do this
✓ Copy from programming the rule “ready is what can be proven, not what is declared”.
✗ Avoid this mistake
✗ Think these practices only serve people who write code.
Practice before you reveal
Choose two items from the list (for example, planned mode and failure log) and describe how you would apply each one to a task that isn’t programming.
View commented answer
Planned mode becomes “show me the email script before sending”; failure log becomes a table with date, error, and the agent’s support-team correction. The practice is the same; only the object changes.
Permission modes are the N0–N4 ladder with a button
What it is
In Claude Code, permission mode defines what the agent can do without asking. In plan, it only reads and proposes; in default, it asks for approval for every edit or command; in acceptEdits, it edits files on its own, but commands still ask; in bypassPermissions, it allows everything. It’s the same N0 to N4 autonomy ladder—just with a button instead of a conversation.
Why learn
Choosing the “on the fly” mode is the most common mistake people make when they start with code agents. With the ladder, the choice becomes rule-based: the level comes from the action and the risks, not from urgency. And it becomes clear what has to happen in order to move up a rung.
Key concepts
Goal: choose the permission mode based on the level, not on impulse.
Level rule (from the skill agent sheet):
consulta → N0 · prepara/rascunho → N1 · executa → N3 · coordena processo → N4
if N3+ E (money OR irreversible OR people from outside) → N2
if N2+ E and no official source is defined → N1
Map to Claude Code:
N0/N1 → plan
N2 → default + prohibitions as deny rules
N3 → acceptEdits + tests as the “ready” criterion + FALHAS.md
N4 → hooks that block push, deploy, and delete + isolated environment
My case: task <describe> → level <Nx> → mode <mode>
How to check: if the chosen mode is above what the level rule allows, bring it down. If you’re between two options, choose the lower one.
✓ Do this
✓ Start in plan or default and move up one step only after weeks without corrections.
✗ Avoid this mistake
✗ Use bypassPermissions in a repository connected to production.
Practice before you reveal
Your agent will correct website texts and also publish the new version live. Which level and which mode does the rule indicate?
View commented answer
Publishing live is irreversible and involves people outside (visitors), so the rule lowers it to N2: default mode, with publishing as a deny rule. It edits, you approve, and you publish. You can move up when there are weeks of approvals without corrections.
Instructions, tests, and hooks: the method in production
What it is
Three pieces turn the principles into real configuration. The instruction file (CLAUDE.md for the Claude Code, AGENTS.md for Codex and others) sits at the root of the project and is read in every session. Tests are commands that automatically verify whether the work is correct. Hooks are triggers that run before an action and can block it; the allow and deny rules in the configuration grant or prohibit actions.
Why learn
Writing “don’t deploy” in the conversation isn’t enough: the conversation ends and the rule disappears. In the instruction file, it applies every time; as a deny rule or hook, it applies even if the agent forgets. It’s the difference between asking and guaranteeing.
Key concepts
Objective: paste the agent’s level and prohibitions into CLAUDE.md or AGENTS.md.
## Agent for this project
Level: <N2> · <prepare, you approve>. Permission mode: <default>.
Mission: <what it does and why it matters>.
Source of truth: the repository. Read the file before making any claims about it.
Ready = <npm test> passes with no errors. Don’t declare ready before that.
### Never do it alone
- git push, deploy, or publishing
- delete files or folders outside <working directory>
- modify <.env / client data>
If they ask, tell them you’re passing it to me.
### Stop and call me when
- a test fails two times in a row
- the task requires working outside <working directory>
### Log
Log each failure in FALHAS.md: date, what broke, smallest correction.
How to verify: open a new session and ask, “summarize in 3 lines your rules for this project”; it should mention the level, the ready criterion, and the prohibitions.
From concept to action
- Written instruction: identify the initial condition.
- Automated test: apply the described decision.
- Deny rule: check the effect in the example.
- Hook that blocks: record the output evidence.
✓ Do this
✓ Repeat severe prohibitions as a deny rule or hook, in addition to the text.
✗ Avoid this mistake
✗ Trust only the chat request for something irreversible.
Practice before you reveal
Take the CLAUDE.md or AGENTS.md from one of your projects (or create one) and add the level block, ready criterion, and three prohibitions.
View commented answer
The minimum block has level, source of truth, definition of ready, and prohibitions with “if they ask, pass it to me”. If the project has deploy, the deploy prohibition must also become a deny rule, because the text alone depends on the agent obeying.
The bottleneck is clarity, not AI
What it is
The 7 questions are the same ones a good manager always asked. Without intention, the agent efficiently does the wrong task; without a source of truth, it picks the information on its own and picks badly; without criteria, it says “done” and you only find out later that it wasn’t. And the design of the principles is a circle: supervision feeds back into intention, each mistake becomes a rule, and each clean week becomes a rung of autonomy.
Why learn
Blaming “the AI” prevents you from fixing what’s within your reach: delegation. When you treat each error as a missing rule, the agent improves week after week without switching tools. The circle turns the Agent Sheet into a living process, not a form you fill out once.
Key concepts
Goal: turn an agent mistake into a rule instead of blaming the tool.
Observed error: <what it did wrong>
Which principle was missing? (check one)
[ ] intention [ ] context [ ] data [ ] criteria
[ ] autonomy [ ] observation [ ] supervision
New rule (one sentence): <e.g., “if the price isn’t in the table, write [MISSING PRICE]”>
Where it goes: <agent sheet section or <CLAUDE.md>>
Line in the log: | <date> | <what broke> | <smallest fix> | <rule updated> |
How to check: repeat the same situation the following week; if the error doesn’t come back, the rule worked.
✓ Do this
✓ For each mistake, ask “which of the 7 questions did I not answer?”
✗ Avoid this mistake
✗ Switch tools or models before reviewing the instruction.
Practice before you reveal
Think of a recent error from an AI you use. Classify it into one of the three symptoms (intention, source, criterion) and write the rule that would prevent it.
View commented answer
Almost always, the error fits into one of the three: wrong task (intention), wrong data (source), or incomplete delivery (criterion). A good rule is short, specific, and testable the following week.
Check your understanding
An agent delivered, with great efficiency, a report about the wrong topic. According to the secret of the 7 principles, what’s the most likely cause?
What you take from this module
Recognize each principle in a management practice you already use and translate it into written instructions for an agent, including a code agent.
- People management, under another name.
- What the agent doesn’t “pick up on the fly”.
- If you program with agents, you’re already living this.
- Permission modes are the N0–N4 ladder with a button.
- Instructions, tests, and hooks: the method in production.
- The bottleneck is clarity, not AI.
Next action: apply what you learned to your agent sheet and note what still needs review.