Ești un inginer senior [limbaj/framework] care revizuiește codul pentru [proiect/domeniu].
Obiectiv: [Corectare erori | Performanță | Lizibilitate | Securitate | Experiența dezvoltatorului | Coerența API]
Constrângeri: [Ghid de stil, versiuni suportate, limite de memorie/timp, constrângeri de bibliotecă]
Context:
- Runtime/Env: [Node 20, JVM 17, Python 3.11, iOS 17, etc.]
- Dependențe cheie: [listă]
- Arhitectură: [monolit, microservicii, serverless, hexagonal, etc.]
- Interfețe/contracte relevante: [link sau inline]
Sarcină:
1) Revizuiește următorul cod pentru [obiective].
2) Identifică probleme specifice cu dovezi (referințe de linie, estimări de complexitate, cazuri extreme).
3) Propune diferențe minime, direcționate.
4) Oferă o versiune refactorizată finală.
5) Explică compromisurile și riscurile.
Cod:
```[limbaj]
// lipește codul aici

Obiectiv: reducerea complexității temporale și a memoriei fără a modifica comportamentul public.
Oferă: complexitatea actuală, complexitatea propusă, micro-optimizări vs. modificări algoritmice și benchmark-uri de rulat.

Refactorizează pentru claritate: nume mai bune, funcții mai mici, responsabilitate unică.
Adaugă docstring-uri/JSDoc, simplifică fluxul de control, elimină codul mort. Păstrează API-ul public stabil.

Model de amenințare: intrare nesigură de la [sursă].
Verifică: injecție, deserializare, SSRF, XSS, CSRF, authZ/authN, gestionarea secretelor.
Sugerează: biblioteci sigure, tipare de validare și diferențe minime.

Migrăm de la [lib A] la [lib B].
Enumeră modificările distructive, propune un strat de adaptor și oferă un plan de lansare incrementală cu teste.

Env: Python 3.11, FastAPI, Pydantic v2.
Contract: endpoint-ul trebuie să returneze 200 cu { data, meta } chiar și în cazul eșecurilor parțiale.
Constrângere: trebuie să rămână asincron; nu se pot adăuga noi dependențe grele.

1) Critica: enumeră probleme concrete cu dovezi.
2) Diferența: cele mai mici modificări pentru a remedia.
3) Refactorizare: cod final curat, idiomatic.
4) Teste: teste unitare care acoperă calea fericită + 3 cazuri extreme.

Propune 3 opțiuni de refactorizare:
- Opțiunea A: modificare minimă
- Opțiunea B: reproiectare moderată
- Opțiunea C: rescriere completă
Pentru fiecare: avantaje/dezavantaje, complexitate, risc, plan de migrare și când să o alegi.

Constrângeri: același API public, <50ms p95, <10MB memorie suplimentară, fără noi dependențe runtime.
Arată cum refactorizarea ta îndeplinește fiecare constrângere cu măsurători sau raționamente.

Ești un inginer Python senior. Obiectiv: corectitudine + performanță.
Env: Python 3.11, FastAPI, httpx, Pydantic v2. Contract: nu ridica niciodată în cazul unui eșec parțial.
Sarcină: revizuiește și refactorizează. Oferă critică → diferențe minime → refactorizare finală → teste.
Cod:
```python
from fastapi import APIRouter
import httpx
router = APIRouter
@router.get("/users/{user_id}")
async def get_user(user_id: str):
async with httpx.AsyncClient as client:
profile = await client.get(f")
posts = await client.get(f")
return {"data": {"profile": profile.json, "posts": posts.json}}

Adnotează fiecare sugestie cu: {severitate, categorie, argumentație}. Include snippet-uri înainte/după și un plan de migrare într-un singur pas dacă comportamentul s-ar putea schimba.

Returnează ieșirea ca o diferență unificată cu căile de fișiere corecte din rădăcina acestui depozit. Include doar hunks modificați. Fără comentarii în diferență. Apoi include o secțiune separată pentru note.

Răspunde cu exact două blocuri:
1) ```diff
...modificări...

Explică fiecare modificare într-o singură propoziție cu o linie sau un snippet citat. Dacă nu ești sigur, pune o întrebare de clarificare în loc să ghicești.

Dacă cerințele sunt ambigue, pune până la 3 întrebări de clarificare înainte de a continua.

Rol: Inginer senior TypeScript.
Obiectiv: îmbunătățirea lizibilității și a siguranței runtime fără a modifica API-ul public.
Env: Node 20, TypeScript 5.4, Zod pentru validare, ESLint Airbnb, strictNullChecks.
Constrângeri: fără noi dependențe runtime dincolo de Zod, fără modificări distructive, menține complexitatea O(n).
Sarcină:
- Critica → Diferența → Refactorizare → Teste → Note.
- Etichetează problemele cu {severitate, categorie, argumentație}.
- Include o schemă Zod pentru validarea intrărilor și 4 teste unitare.
Cod:
```ts
export function parseUser(raw: any) {
if (!raw) return null
return {
id: raw.id || '0',
name: raw.name || 'Unknown',
age: parseInt(raw.age),
}
}

Rulează o trecere mentală ESLint și enumeră încălcările pe care te-ai aștepta să le vezi, apoi remediază-le.

Pentru fiecare modificare, numește tiparul de refactorizare (de ex., Extract Function, Introduce Parameter Object) și explică când să-l aplici în această bază de cod.

Utilizează doar contextul depozitului. Revizuiește fișierele modificate în acest PR pentru [obiectiv]. Adnotează constatările inline cu severitate și argumentație. Propune diferențe care păstrează API-ul public și NFR-urile. Include teste care ating doar căile modificate.