Gemini 2.5 Pro – Cas d’Usages Concrets (Guides pas à pas)

Livrer un CRUD minimal exploitable : modèle, admin, vue liste, URL, template, tests, sortie structurée (JSON ou diff unifié) pour automatiser côté backend.

🎯 Objectif & contraintes

• App blog, modèle Article(title, slug unique, body, is_published, published_at).
• Admin list + search + filters, ListView paginée, template minimal.
• Tests (liste non vide + création).
• Format : bloc par fichier ou JSON validé par schéma (si modif → diff).

🧩 Schéma de sortie (Vertex AI, Python)

from vertexai.generative_models import GenerationConfig, ResponseSchema
schema = ResponseSchema(type="object", properties={
  "files":{"type":"array","items":{"type":"object","properties":{
    "path":{"type":"string"},"action":{"type":"string","enum":["create","patch"]},
    "content":{"type":"string"}}}},
  "commands":{"type":"array","items":{"type":"string"}}
}, required=["files"])
cfg = GenerationConfig(response_mime_type="application/json", response_schema=schema)

🧱 Patron de prompt pour Gemini 2.5

RÔLE : Architecte Django senior
OBJECTIF : CRUD minimal Article (modèle + admin + ListView + URL + template + tests)
CONTRAINTES : chemins exacts, bloc par fichier ; si modif → DIFF UNIFIÉ
BORNES : ≤ 120 lignes ; sinon STOP & propose un split
SORTIE : fichiers + commandes manage.py + tests pytest

📦 Exemples de fichiers (extraits)

FICHIER: blog/models.py
from django.db import models
from django.utils.text import slugify
class Article(models.Model):
    title = models.CharField(max_length=180)
    slug = models.SlugField(max_length=200, unique=True)
    body = models.TextField()
    is_published = models.BooleanField(default=False)
    published_at = models.DateTimeField(null=True, blank=True)
    def save(self,*a,**kw):
        if not self.slug: self.slug = slugify(self.title)[:200]
        super().save(*a,**kw)
    def __str__(self): return self.title

FICHIER: blog/admin.py
from django.contrib import admin
from .models import Article
@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
    list_display = ("title","is_published","published_at")
    list_filter = ("is_published",)
    search_fields = ("title","slug")

FICHIER: blog/views.py
from django.views.generic import ListView
from .models import Article
class ArticleListView(ListView):
    model = Article; paginate_by = 10
    template_name = "blog/article_list.html"

FICHIER: blog/urls.py
from django.urls import path
from .views import ArticleListView
urlpatterns = [ path("", ArticleListView.as_view(), name="article_list"), ]

FICHIER: templates/blog/article_list.html
<h1>Articles</h1>
<ul>{% for a in object_list %}<li>{{ a.title }}</li>{% empty %}<li>Aucun.</li>{% endfor %}</ul>

FICHIER: tests/test_blog.py
import pytest
from blog.models import Article
@pytest.mark.django_db
def test_article_list_view(client):
    Article.objects.create(title="Hello", slug="hello", body="x", is_published=True)
    r = client.get("/blog/"); assert r.status_code==200 and b"Articles" in r.content

⚙️ Commandes

python manage.py makemigrations blog
python manage.py migrate
pytest -q

Deux couches : balises Django i18n ({% trans %}, {% blocktrans %}) et pipeline .po/.mo. Fournis un prompt context pack pour générer les balises correctes et l’extraction.

🧱 Balises i18n (extrait)

FICHIER: templates/common/navbar.html
<nav>
 <a href="/">{% trans "Accueil" %}</a>
 <a href="/about/">{% trans "À propos" %}</a>
 <a href="/contact/">{% blocktrans %}Contactez-nous{% endblocktrans %}</a>
</nav>

🛠️ Extraction & compilation

django-admin makemessages -l en -l es
# éditer locale/<lang>/LC_MESSAGES/django.po
django-admin compilemessages

📦 Prompt Gemini (gabarit)

RÔLE : Développeur Django
OBJECTIF : Ajouter i18n aux templates donnés
CONTRAINTES : Utiliser {%trans%} / {%blocktrans%}, ne pas modifier la logique
SORTIE : blocs par fichier + commandes makemessages/compilemessages

🧪 Test rapide

LANGUAGE_CODE="en"; assert "About" in render("common/navbar.html")
LANGUAGE_CODE="fr"; assert "À propos" in render(...)

Un bon debug = Repro courte → Surface → Hypothèse → Patch minimal → Test qui échoue avant / passe après.

🧪 Evidence Pack (prompt)

REPRO : étapes exactes + payload + URL
TRACE : 20 lignes max
SURFACE : fichiers suspects (chemins + lignes)
ATTENDU : ce qui devrait se passer
SORTIE : DIFF UNIFIÉ + test(s) + commande

🐍 Exemple Python

# Patch minimal (diff)
--- a/accounts/models.py
+++ b/accounts/models.py
@@ -12,6 +12,7 @@
- email = models.EmailField()
+ email = models.EmailField(unique=True)

🟨 Exemple JS

// Bug : this non lié dans un handler
btn.addEventListener('click', this.handleClick);
// Patch
btn.addEventListener('click', (e) => this.handleClick(e));

📋 Vérifs

python -m py_compile $(git ls-files "*.py")
pytest -q
npm run test -s

Objectifs : plus vite, moins cher, fiable. Stratégies : profiling, batch/chunk, I/O asynchrone, idempotence, reprises sur erreur, métriques.

⚙️ Patterns efficaces

• Batching : bulk_create, bulk_update, chunks 1k–10k.
• DB : select_related/prefetch_related, index sur filtres/tri.
• I/O : sessions HTTP, parallélisme limité, backoff.
• Idempotence : get_or_create, verrous applicatifs, clés uniques.
• Observabilité : logs structurés, latence, rows/s, taux d’erreur.

# Traitement par paquets
qs = Model.objects.filter(processed=False).only("id").order_by("id")
BATCH=1000; buff=[]
for obj in qs.iterator(chunk_size=BATCH):
    obj.processed=True; buff.append(obj)
    if len(buff) >= BATCH: Model.objects.bulk_update(buff, ["processed"]); buff.clear()
if buff: Model.objects.bulk_update(buff, ["processed"])

🧪 Mesurer

python -m cProfile -o profile.out manage.py your_command
snakeviz profile.out

🧾 Cron (ex.)

0 2 * * * /path/venv/bin/python /path/app/manage.py your_command --quiet >> /var/log/cron.log 2>&1

Un plan utile = objectifs mesurables → modules → exercices → évaluations → livrables. Le tout exportable en JSON.

🎯 Objectifs (ex. Dev Web & IA)

• Scaffold Django/React exploitables avec Gemini 2.5.
• i18n, tests, CI simple, patterns RAG/Grounding.
• Optimiser un cron avec métriques d’observabilité.

📦 Programme (ex. 2 jours)

J1 AM : Prompting & Contexte (patterns, checklists)
J1 PM : Django CRUD + tests (atelier guidé)
J2 AM : i18n + React component + tests
J2 PM : Cron optimisation + mini-projet évalué

🧱 Modèle JSON (export)

{
  "title": "Bootcamp Dev Web & Gemini 2.5",
  "duration_hours": 14,
  "objectives": ["Scaffold Django/React", "i18n", "Tests & CI", "Cron perf"],
  "modules": [
    {"title":"Prompting & Contexte","hours":3},
    {"title":"Django CRUD + Tests","hours":4},
    {"title":"i18n & React","hours":3},
    {"title":"Cron & Observabilité","hours":4}
  ],
  "evaluation": {
    "quiz": 20,
    "project": {"dod":["PEP8","tests OK","doc courte"], "deadline":"J+2 18h"}
  }
}

📎 Livrables

• Slides PDF + dépôt Git d’atelier + énoncé/corrigé.
• Grille d’évaluation & feedback standardisés.