---
title: "Quick Start - First Session Demo"
version: "1.0"
audience: "New Agent"
---

# ⚡ Quick Start - Your First Agent Session

**Copy this flow for your first session.**

---

## 🚀 Your First 15 Minutes

### Minute 1-2: Read Navigation

```
OPEN: .github/instructions/INDEX.md
READ: Navigation section
KNOW: What files exist and when to read them
TIME: 2 minutes
```

### Minute 3-4: System Overview

```
OPEN: .github/instructions/README_AGENT_SYSTEM.md
SCAN: System overview section
UNDERSTAND: How 5-Layer protocol works
TIME: 2 minutes
```

### Minute 5-6: Boot Protocol

```
OPEN: .github/instructions/AGENT_BOOT_PROTOCOL.md
READ: Entire file
MEMORIZE: You'll use this every session
TIME: 2 minutes
```

### Minute 7-8: Core Framework

```
OPEN: .github/instructions/AGENT_AUTONOMOUS_PROTOCOL.md
READ: "Core Protocol: 5-Layer Decision Framework" section only
UNDERSTAND: How to work (Layers 1-5)
TIME: 2 minutes
```

### Minute 9-10: Decision Logic

```
OPEN: .github/instructions/TRIGGER_RULES.md
READ: Decision Matrix section
BOOKMARK: For when you have a task
TIME: 2 minutes
```

### Minute 11-15: Quick Reference

```
OPEN: .github/instructions/VISUAL_GUIDE.md
SCAN: Entire file
PRINT: Optional (one-page reference)
TIME: 4 minutes
```

**Total: ~15 minutes. Now you're ready.**

---

## 📋 First Task Template

### You Get Your First Task

```
"Crée un composable pour filtrer les trips par distance"
```

### Follow This Exact Flow:

```
STEP 1: Identify Type
  Question: Is this CREATE/FIX/REFACTOR/QUESTION/REVIEW?
  Answer: CREATE
  Action: Open TRIGGER_RULES.md
  Read: "REQUEST TYPE 1: Create/Add"
  Time: 1 minute

STEP 2: Boot Protocol
  Action: Open AGENT_BOOT_PROTOCOL.md
  Read: Pre-Coding Checklist section
  Complete: All items ✓
  Time: 2 minutes

STEP 3: Layer 1 - UNDERSTAND
  Action: Open docs/technical/reference.md
  Search: "trip" "filter" "composable"
  Find: Related files
  Task: List 5-10 related files
  Time: 5 minutes

STEP 4: Layer 2 - VALIDATE
  Question: Does similar file exist?
  Search: grep -r "useTrip" composables/
  Find: Any existing patterns
  Validate: Safe to proceed?
  Time: 2 minutes

STEP 5: Layer 3 - IMPLEMENT
  Find: Similar composable (pattern)
  Copy: Template structure
  Create: useDistanceFilter.ts
  Build: npm run build:frontend
  Check: 0 errors? YES ✓
  Time: 15 minutes

STEP 6: Layer 4 - DOCUMENT
  Update: docs/technical/reference.md
    Add: - **useDistanceFilter** (composables/useDistanceFilter.ts)
  Update: composables/index.ts
    Add: export { useDistanceFilter }
  Update: AGENTS.md (if needed)
  Check: No broken links?
  Time: 3 minutes

STEP 7: Layer 5 - VERIFY
  Check: Build passes? YES ✓
  Check: TypeScript clean? YES ✓
  Check: Imports resolve? YES ✓
  Check: Docs complete? YES ✓
  Mark: COMPLETE ✅
  Time: 2 minutes

TOTAL TIME: ~30 minutes
RESULT: Feature complete + documented + verified
```

---

## 🎯 Copy-Paste Workflow

### For Every New Task

```
1. IDENTIFY TYPE (1 min)
   └─ Is it CREATE/FIX/REFACTOR/QUESTION/REVIEW?

2. READ BOOT_PROTOCOL (2 mins)
   └─ .github/instructions/AGENT_BOOT_PROTOCOL.md

3. LAYER 1: UNDERSTAND (5 mins)
   ├─ docs/technical/reference.md → Find domain
   ├─ grep → Find related files
   ├─ Trace → Data flow
   └─ List: [file1, file2, file3, ...]

4. LAYER 2: VALIDATE (2 mins)
   ├─ Single responsibility? YES
   ├─ Data flow complete? YES
   └─ Safe to proceed? YES

5. LAYER 3: IMPLEMENT (variable)
   ├─ Copy pattern from existing code
   ├─ Write code
   ├─ Build: npm run build:frontend
   └─ Check: 0 errors

6. LAYER 4: DOCUMENT (2-3 mins)
   ├─ Update docs/technical/reference.md
   ├─ Update index.ts files
   └─ Check: No broken links

7. LAYER 5: VERIFY (2 mins)
   ├─ Build passes? ✓
   ├─ TypeScript clean? ✓
   ├─ Imports resolve? ✓
   └─ Mark: COMPLETE ✅
```

---

## 🎓 Real Example Walkthrough

### Task: "Crée une page Season pour mobile et web"

```
STEP 1: IDENTIFY
  Type: CREATE → Full 5-Layer protocol

STEP 2: BOOT
  Read: AGENT_BOOT_PROTOCOL.md
  Checklist: ✓ Ready to start

STEP 3: UNDERSTAND (5 mins)
  Open: docs/technical/reference.md
  Search: "season"
  Find:
    - SeasonSection component exists
    - pages/season/ folder exists
    - useGamifyStore exists
  Related files:
    1. components/season/SeasonSection.vue
    2. stores/useGamifyStore.ts
    3. composables/useSeasonPageLogic.ts (EXISTS!)
    4. pages/season/mobile/
    5. pages/season/web/

STEP 4: VALIDATE (2 mins)
  Check: Pattern exists (MobileSeasonPage example)
  Check: useSeasonPageLogic exists (can reuse)
  Check: Safe to create pages? YES
  Go: PROCEED

STEP 5: IMPLEMENT (15 mins)
  Copy: MobileProfilePage.vue as template
  Create: MobileSeasonPage.vue (30 lines)
    - Import useSeasonPageLogic composable
    - Import SeasonSection component
    - Template renders section
  Create: WebSeasonPage.vue (40 lines)
    - Same logic, different layout
  Build: npm run build:frontend
  Result: ✓ built in 4.05s (0 errors)

STEP 6: DOCUMENT (3 mins)
  Update: docs/technical/reference.md
    Add: - **MobileSeasonPage** (pages/season/mobile/MobileSeasonPage.vue)
         - **WebSeasonPage** (pages/season/web/WebSeasonPage.vue)
  Update: pages/season/index.ts
    Add: exports for both pages
  Update: AGENTS.md domain:season
    Add: Pages section

STEP 7: VERIFY (2 mins)
  ✓ Build passes: YES
  ✓ TypeScript clean: YES
  ✓ Can import: YES (import { MobileSeasonPage } from '@/pages/season')
  ✓ Docs updated: YES
  Status: COMPLETE ✅

TOTAL: ~30 minutes
DELIVERABLE: 2 pages + updated documentation + verified build
```

---

## 📚 When You're Stuck

### "I'm confused about what to do"
```
→ Open: README_AGENT_SYSTEM.md
→ Read: "Quick Start by Request Type"
→ Time: 2 minutes
```

### "I don't know the data flow"
```
→ Open: docs/technical/reference.md
→ Search: Your domain
→ Read: Related components and endpoints
→ Time: 3 minutes
```

### "I don't know which pattern to use"
```
→ Open: AGENT_AUTONOMOUS_PROTOCOL.md
→ Read: "Pattern Library Reference"
→ Find: Similar code
→ Time: 3 minutes
```

### "I'm not sure how to update docs"
```
→ Open: DOCUMENTATION_SYNC.md
→ Read: "Smart Sync Checklist"
→ Follow: Step by step
→ Time: 2 minutes
```

### "I'm stuck on Layer X"
```
→ Open: TRIGGER_RULES.md
→ Find: Your scenario
→ Read: Detailed steps
→ Time: 3 minutes
```

---

## ✅ Session Exit Checklist

### Before You Mark Task COMPLETE

```
□ Build passes? (npm run build:frontend)
  └─ 0 errors? YES

□ TypeScript clean?
  └─ 0 TypeScript errors? YES

□ Imports resolve?
  └─ Related files can import? YES

□ Documentation updated?
  └─ docs/technical/reference.md? YES
  └─ index.ts files? YES
  └─ AGENTS.md (if needed)? YES

□ 5 Layers complete?
  └─ Layer 1: UNDERSTAND? YES
  └─ Layer 2: VALIDATE? YES
  └─ Layer 3: IMPLEMENT? YES
  └─ Layer 4: DOCUMENT? YES
  └─ Layer 5: VERIFY? YES

ALL YES? → Mark COMPLETE ✅
ANY NO? → Go back and fix
```

---

## 🎯 3 Sessions Progression

### Session 1: Learning
```
Time: 30 minutes
Activity:
  - Read system documentation (15 mins)
  - First task using 5-Layer (15 mins)
  - Might be slow, but thorough
Output: Working feature + complete docs
```

### Session 2: Familiar
```
Time: 20 minutes
Activity:
  - Boot protocol (2 mins)
  - Pick task type (1 min)
  - Execute 5-Layer (15 mins)
  - Know patterns now
Output: Working feature + complete docs
```

### Session 3+: Automatic
```
Time: 15 minutes
Activity:
  - Boot protocol (2 mins)
  - Execute 5-Layer (automatically, 12 mins)
  - Process becomes second nature
Output: Working feature + complete docs
```

---

## 🚀 First Session Checklist

```
□ Read all 7 instruction files (15 mins)
□ Understand 5-Layer protocol
□ Know when to apply TRIGGER_RULES
□ Get your first task
□ Follow the workflow above
□ Complete task using 5-Layer
□ Verify: Build passes, docs updated
□ Mark: COMPLETE ✅
□ Celebrate! 🎉
```

---

## 📊 Quick Reference Card

**Print this and keep it handy:**

```
┌─────────────────────────────────────────────┐
│ QUICK REFERENCE                             │
├─────────────────────────────────────────────┤
│                                             │
│ 5 Layers (Every Task):                     │
│ 1. UNDERSTAND (5 min)   - Read, research   │
│ 2. VALIDATE (3 min)     - Check logic      │
│ 3. IMPLEMENT (var)      - Write code       │
│ 4. DOCUMENT (2-3 min)   - Update refs      │
│ 5. VERIFY (2 min)       - 0 errors        │
│                                             │
│ Total: 15-60 minutes per task              │
│                                             │
│ Reference Files:                           │
│ - docs/technical/reference.md    - All symbols       │
│ - AGENTS.md            - Workspace map     │
│ - TRIGGER_RULES.md     - When to apply    │
│ - DOCUMENTATION_SYNC   - How to sync      │
│                                             │
│ Red Flags (STOP):                          │
│ ❌ File > 300 lines    ❌ Build errors    │
│ ❌ Function > 30 lines ❌ No types        │
│ ❌ Imports from 5+     ❌ Out of sync     │
│                                             │
│ Success = All 5 Layers + Build Passes      │
│                                             │
└─────────────────────────────────────────────┘
```

---

## 🎓 After Your First Session

### Reflect
```
□ Did the 5-Layer protocol work?
□ Was documentation updated smoothly?
□ Did build pass on first try?
□ Any improvements to the system?
```

### Learn
```
□ Remember patterns you used
□ Note which files to search
□ Remember which docs to read
□ Build mental map of workspace
```

### Improve
```
□ If you found better pattern → Update docs
□ If trigger scenario unclear → Update TRIGGER_RULES
□ If sync was hard → Update DOCUMENTATION_SYNC
□ If something confusing → Update README
```

---

## 🌟 You're Ready!

```
✅ System understood
✅ Protocol clear
✅ First task ready
✅ Checklist prepared
✅ Emergency guide ready

→ Go start your first session! 🚀

Remember:
  1. Read docs first
  2. Follow 5-Layer
  3. Update references
  4. Verify completeness
  5. Mark done

That's it. You've got this.
```

---

**Version:** 1.0  
**Status:** Ready to Use  
**Next:** Start your first session! 🚀
