Claude Code oublie tout ? Voici les fichiers à créer (CLAUDE.md, rules, settings)

Summary of technological concepts & product features (Claude Code / Cloud Code)

Core problem: “Claude/Cloud Code forgets” between sessions

• Without configuration, Cloud Code doesn’t know your:
  • Tech stack
  • Naming conventions
  • Styles
• As a result, it may:
  • Repeat the same mistakes
  • Ask the same questions every session
• The fix is framed as making Claude a more consistent “teammate” by giving it reusable project knowledge.

Solution: a 3-layer configuration system (accumulating knowledge)

1. Project layer (team-shared)

   • In the project, create files like:
     • cloud.md
     • settings.json
     • and related docs/rules
   • These are shared with the team.

2. Local layer (personal overrides)

   • Keep a “local” config file (prefixed with local) out of version control (e.g., add it to .gitignore).
   • Used for your personal working style so Claude learns it.

3. User/global layer (root of the user machine)

   • At the user’s home/hard-drive root (a global “cloud point”), store global:
     • global cloud.md
     • global settings.json
   • Applies across projects and sessions.

Priority rule: project cloud.md takes precedence over global during load.

---

cloud.md = “brain” / main context file

• Loaded first each session, followed by the user prompt.
• Should contain concise but complete project context, including:
  • Technical stack
  • Commands
  • Naming conventions
  • Architecture / technical decisions
  • Business rules
  • What kinds of content it should write (e.g., marketing pages, blog articles)
  • When it may write content (e.g., specific pages or conditions)

What NOT to put in cloud.md:

• Secrets/tokens/passwords
• Personal preferences that belong in local settings
• Long procedures (convert them into skills)
• Vague instructions (can lead to “precise nonsense”)

Maintainability guidance

• Recommended cloud.md length: ≤ 200 lines (for performance/readability)
• Prefer splitting instructions using imported MD “points”:
  • Create additional rule/doc files (e.g., “things to do” / “things not to do”)
  • Import them into cloud.md

---

Variants / placement of cloud.md files

Multiple placement strategies are mentioned, including:

• Team-accessible/project guide versions
• Root project cloud.md (global inside the project)
• Folder-level cloud.md that applies only within that folder (triggered when Claude touches relevant source files)

Rule conflict resolution: most specific wins

• Example: a folder-level cloud.md overrides a project-level one if it’s more specific.

---

Rules files (modular enforcement)

• Rules can be defined at project/global scope, and optionally targeted by file type (e.g., API files vs components).
• Highlighted benefits:
  • Rules load only when relevant files change (context saving + performance)
  • Keeps cloud.md short
  • Enables strict enforcement (e.g., “validate API inputs with ZOD”)

Examples of rule categories mentioned:

• APIs
• Tests
• Components
• Migrations

---

settings.json (technical permissions & behavior control)

• Distinction:
  • cloud.md = context “Claude tries to follow”
  • settings.json = forced/non-negotiable behavior
• Configures:
  • Permissions (read/write, allowed patterns, etc.)
  • Allowed/blocked capabilities for commands/tools
  • Hooks and lifecycle scripts
  • Environment/model choices
  • Response style
  • Memory enrichment options during discussion

Hooks are described as scripts executed automatically during an agent lifecycle.

---

Skills (reusable workflows invoked on demand)

• Skills are reusable workflows loaded only when invoked via a slash command (e.g., /skillname).
• Include:
  • Name + concise description
  • Tools/commands available + arguments
  • Scripts (e.g., scripts.sh) for steps inside the skill workflow
• Important behavioral rule:
  • Skills should not contain “permanent rules”
  • Permanent enforcement belongs in rules / `cloud.md
• Skills can call agents and other components to form larger workflows (similar to a node/workflow concept).

---

Agents (specialized sub-agents)

• Agents act like specialized roles, e.g.:
  • code reviewer agent
  • search agent
• Config includes:
  • Name, description, model
  • Allowed/forbidden commands/tools
• Purpose:
  • Focus tasks
  • Enforce feedback formats
  • Isolate/summarize context so the main thread isn’t polluted
  • Delegate automatically when tasks match the agent’s description
• Cost control benefit:
  • Assign cheaper models to sub-tasks.

---

MCPs (external servers / tool integrations)

• MCPs are external servers added at the project root.
• Multiple MCPs can be shared with the team.
• Examples mentioned:
  • GitHub actions MCP
  • Stripe data MCP
  • Documentation/search MCP
• Security best practice:
  • Reference secrets in settings.json / a secret file
  • Never store secrets inside MCP files

Personal MCPs:

• Keep them in the user/local “cloud” areas (not shared).

---

Tutorial/demo structure described at the end

• The video demonstrates creating a full configuration for an example project:
  • Uses the “Horizon Agency” project as the baseline.
• Claude Code is asked to generate needed files:
  • cloud.md
  • rules (initially none, later added)
  • settings.json
  • skills
  • MCP setup
  • hooks (e.g., pre-tool hook for a linter / post-lint fixing)

Example hook described:

• “anti-quadratin” / anti “double shot”
• Uses a repeated linting tool with:
  • pre-tool validation
  • post-tool actions to fix ESLint errors

It also signals future content:

• Next: authentication system for an agency dashboard + client dashboard
• References other videos for website creation/deployment end-to-end

---

Five pitfalls to avoid (beginner mistakes)

1. Using cloud.md as a catch-all

   • Keep cloud.md under ~200 lines
   • Move long procedures into skills
   • Put heavy/slow logic into rules

2. Confusing context with security

   • cloud.md doesn’t block actions
   • Permission/action blocking is done via settings.json

3. Committing local settings

   • Don’t push personal/local config
   • Use .gitignore

4. Confusing skills with permanent rules

   • Skills can be removed/recreated
   • Permanent enforcement belongs in rules / cloud.md

5. Duplicating instead of importing

   • Reuse files via imports
   • Avoid divergence by keeping a single source of truth

---

Review/audit offer mentioned (analysis/tutor support)

• The creator offers a free 30-minute automation audit (link in description).
• Promise:
  • Analyze business processes to determine what can be automated with AI/Claude Code
• Claimed impact:
  • ~10–30 hours saved on repetitive tasks (time reallocated to clients/family)

---

Main speakers / sources

• Primary speaker: the video creator/instructor (referred to with phrasing like “I’ll let you resume,” plus references to preparing the free audit and future videos)
• Main source material: Cloud Code documentation concepts reflected through the recommended files and features:
  • cloud.md, rules, settings.json, skills, agents, MCPs