# Via OpenCode
opencode install oh-my-opencode

# Ou manuellement
git clone https://github.com/code-yeongyu/oh-my-openagent ~/.opencode/plugins/oh-my-opencode

{
  "agents": {
    "build": { "model": "claude-sonnet-4", "tools": ["write", "edit", "bash"] },
    "explore": { "model": "claude-haiku", "tools": ["read", "grep", "glob"] },
    "oracle": { "model": "claude-opus-4", "tools": ["read"] }
  }
}

Request 1 (cold start):
  input_tokens: 2854
  cache_creation_input_tokens: 2727  ← écrit dans le cache
  cache_read_input_tokens: 0

Request 2 (warm):
  input_tokens: 127
  cache_read_input_tokens: 2727      ← lu depuis le cache (90% moins cher)

{
  "system": [
    {
      "type": "text",
      "text": "You are a senior developer...",
      "cache_control": { "type": "ephemeral" }
    }
  ]
}

# RECOMMANDATIONS HN

## Avant de commencer
1. Configurer explicitement le modèle principal ET le small_model
2. Utiliser un user dédié sans accès aux fichiers sensibles
3. Vérifier les permissions avant exécution

## Pendant l'usage
1. Tester dans un container sans internet pour projets sensibles
2. Monitorer les appels réseau (mitmproxy)
3. Piner les versions pour éviter les breaking changes

## Review Checklist (AI-generated code)

### Compréhension
- [ ] Le code est compréhensible sans explication
- [ ] Je peux expliquer chaque fonction à un collègue
- [ ] Pas de "magic" que personne ne comprend

### Qualité
- [ ] Style cohérent avec le reste du code
- [ ] Pas de code mort
- [ ] Dépendances légitimes (vérifier sur npm/pypi)

### Sécurité
- [ ] Pas de credentials en clair
- [ ] Pas d'APIs hallucinées
- [ ] Inputs validate

### Tests
- [ ] Couverture des cas critiques
- [ ] Tests significatifs (pas juste "expect true")
- [ ] Edge cases couverts

# Créer le label
gh label create ai-generated \
  --color B8B8B8 \
  --description "Code généré par IA - review approfondie requise"

# L'appliquer
gh pr edit <number> --add-label ai-generated

# L'agent découvre Rust et Bevy en même temps que vous
cd mon-jeu-bevy
opencode

> I'm new to Rust and Bevy. Suggest a simple 2D game demo I can build.
> Start with movement and collision detection.

# L'agent apprend Elixir avec vous
cd mon-app-phoenix
opencode

> I'm learning Elixir/Phoenix. Help me build a real-time chat app
> with LiveView. What's the simplest starting point?

mkdir mon-projet-ia && cd mon-projet-ia

# Structure
mkdir -p src tests docs
touch AGENTS.md Makefile README.md

# Fichiers IA
touch .opencode/config.json
touch CLAUDE.md  # Optionnel, compatible Claude Code

# AGENTS.md

## Contexte
Ce projet [description]. L'objectif est [objectif].

## Stack technique
- Langage : [Python/JS/Rust]
- Framework : [FastAPI/Express]
- Tests : [pytest/jest]

## Structure
- `src/` : Code source
- `tests/` : Tests
- `docs/` : Documentation

## Conventions
- Style : ruff/black/prettier
- Commits : conventional commits
- PRs : label `ai-generated` obligatoire

## Workflow IA
1. Utiliser Haiku pour exploration/recherche
2. Utiliser Sonnet pour implémentation standard
3. Réserver Opus pour debugging/architecture
4. Générer tests après chaque feature
5. Valider manuellement avant commit

## Prompt Cache Awareness
- Garder le même modèle pendant la session
- Ne pas ajouter/retirer d'outils mid-session
- Timestamp et données dynamiques → en messages

## Coûts
- Budget : $X/mois
- Monitorer usage avec `opencode stats`
- Préférer modèles frugaux

## Guardrails
- ❌ Jamais commit sans comprendre
- ❌ Jamais de credentials en clair
- ❌ Jamais valider dépendances sans vérifier
- ✅ Toujours label `ai-generated` sur PRs
- ✅ Toujours générer tests

YOU: "Je vais te donner deux modèles A et B de façon anonyme.
     Tu dois générer la même réponse avec chacun, puis je voterai."

# Pattern pour choisir entre modèles
YOU: "I need to compare approaches. Give me 3 options:
      1. A simple solution
      2. A robust solution
      3. An experimental solution
      Just list the approaches, don't implement."

// .opencode/config.json
{
  "model": "openrouter/auto",  // Routage automatique vers le meilleur modèle
  // OU
  "model": "anthropic/claude-3-haiku",  // Le moins cher
}

# ÉTAPE 1 : Reflection (modèle gratuit/cheap)
YOU: "Plan this feature. Don't implement yet.
      Think through edge cases, error handling, file structure.
      Output a detailed plan."

# ÉTAPE 2 : Implementation (modèle frugal)
YOU: "Now implement according to your plan. 
      Use the structure you defined.
      One file at a time, with tests."

# Vérifier TOUJOURS après
git diff --stat
make test

{
  "agents": {
    "explore": { "model": "haiku", "tools": ["read", "grep", "glob"] },
    "build": { "model": "sonnet", "tools": ["write", "edit", "bash"] },
    "oracle": { "model": "opus", "tools": ["read"] }
  }
}

YOU: "Add authentication to this app using the orchestrator pattern"

# Oh My OpenCode distribue automatiquement:
# 1. explore agent: lit le code existant
# 2. build agent: implémente l'auth
# 3. oracle agent: review finale

# Script de tracking (à ajouter dans Makefile)
def track_costs():
    """Monitor OpenCode costs from usage logs"""
    # Check cache hit rate
    # Alert if < 80%
    # Budget vs actual

# Cost thresholds
budget_monthly: 50  # USD
alert_threshold: 0.8  # 80% of budget
cache_hit_min: 0.85  # 85% minimum

# Créer la branche projet
git checkout main && git pull
git checkout -b feature/projet-final

# Après création de la structure
git add . && git commit -m "chore: init project structure"

# Après configuration de .opencode/
git add .opencode/ AGENTS.md
git commit -m "chore: add opencode configuration"

# APRÈS chaque étape logique de l'agent
git diff                    # Vérifier les changements
git diff --stat             # Vue d'ensemble
git add src/feature/ && git commit -m "feat: add feature types"
# Slop removal avant commit si nécessaire

# Après génération des tests
git add tests/
git commit -m "test: add tests for feature"

# Si corrections après review
git add src/
git commit -m "fix: address review feedback"

# Push final
git push origin feature/projet-final
gh pr create --label ai-generated

- [ ] Branche créée (pas sur main)
- [ ] Commits atomiques (un concept = un commit)
- [ ] git diff vérifié avant chaque commit
- [ ] Pas de slop (console.log, TODO, code mort)
- [ ] Messages descriptifs (feat/fix/test/docs)
- [ ] Push régulier vers remote

> I've been stuck on this for 3 attempts.
> Here's what I tried:
> 1. [approche 1] → [résultat]
> 2. [approche 2] → [résultat]
> 
> The error is: [erreur complète]
> 
> What should I try next?

## Description
[Description de la feature]

## Changements
- [Liste des changements]

## AI Usage
- [x] Code généré avec IA
- [ ] Code reviewed par humain
- [ ] Compris et validé

## Tests
- [ ] Tests unitaires passent
- [ ] Couverture > 70%

## Checklist Review
- [ ] Compréhensible sans explication
- [ ] Pas de credentials
- [ ] Dépendances vérifiées
- [ ] Style cohérent