Tehnici Avansate de Prompt Engineering în 2026: Ghid Practic

Dacă ai trecut deja de faza „scrie un prompt și speră", articolul acesta este pentru tine. Tehnicile fundamentale (claritate, context, exemple) sunt suficiente pentru cazuri simple. Pentru aplicații reale — în care răspunsurile trebuie să fie consistente, previzibile și verificabile — ai nevoie de un alt set de instrumente.

Diferența între un prompt „care merge" și un prompt production-ready este aceeași ca între un prototip și un sistem care rulează 24/7 pentru clienți reali. Acest ghid acoperă tehnicile pe care echipele de AI Engineering le folosesc în 2026 pentru a duce LLM-urile (Claude Opus 4.7, GPT-5.5, Gemini 3.1) de la „demo impresionant" la „infrastructură de încredere".

Dacă ești complet la început cu prompt engineering, recomandăm întâi articolul nostru Prompt Engineering: de la începător la expert în 30 de zile. Aici trecem direct la tehnicile pe care le folosesc engineers în producție.

De ce tehnicile avansate fac diferența

În 2025, OpenAI și Anthropic au publicat date care arată o diferență dramatică între prompt-urile naive și cele structurate avansat. Pentru sarcini de raționament multi-pas (matematică aplicată, debugging, analiză juridică), aplicarea Chain-of-Thought corect poate îmbunătăți acuratețea cu 20-40 de puncte procentuale — diferența între un sistem care face 3 din 10 sarcini corect și unul care face 7 din 10.

Dar nu e vorba doar de acuratețe. Tehnicile avansate aduc:

• Predictibilitate: răspunsuri în format consistent (esențial pentru integrare API)
• Auditabilitate: pași intermediari vizibili (critic pentru EU AI Act compliance)
• Reducere costuri: prompt-uri mai bune înseamnă mai puține retry-uri și mai puține tokens
• Rezistență la prompt injection: structurile clare protejează împotriva atacurilor

În restul articolului, fiecare tehnică e prezentată cu: ce este, când o folosești, exemplu concret de prompt și ce rezultat obții.

1. Chain-of-Thought (CoT): Gândirea pas cu pas

Ce este: Tehnică prin care soliciți modelului să expliciteze pașii intermediari de raționament înainte de a da răspunsul final. Lansată de echipa Google Brain în 2022, a devenit între timp standard pentru sarcini complexe.

Când o folosești: Probleme care necesită raționament multi-pas — calcule, deducții logice, analiză cauzală, debugging, sinteză din surse multiple.

Exemplu practic — varianta zero-shot:

Prompt:
O fabrică produce 240 piese pe oră în timpul zilei (8 ore) și 180 piese
pe oră noaptea (8 ore). Câte piese produce într-o săptămână de 5 zile,
dacă în weekend producția scade cu 30%?

Hai să gândim pas cu pas.

Adăugarea simplă a frazei „Hai să gândim pas cu pas" (zero-shot CoT) declanșează în Claude Opus 4.7 sau GPT-5.5 un raționament structurat: calculează producția zilnică în zilele lucrătoare, înmulțește cu 5, apoi separat calculează weekend-ul cu reducerea de 30%, apoi sumează. Răspunsul final vine însoțit de toți pașii — verificabili.

Varianta avansată — manual CoT cu exemple:

Prompt:
Vei calcula timpii de procesare pentru comenzi.

Exemplu: O comandă cu 3 produse standard (5 min/produs) și 2 produse
speciale (12 min/produs) durează:
- Produse standard: 3 × 5 = 15 min
- Produse speciale: 2 × 12 = 24 min
- Total: 15 + 24 = 39 minute

Acum calculează pentru: 5 produse standard, 1 special, 2 produse rapide
(2 min/produs).

De ce funcționează: Modelul „învață" pattern-ul de raționament din exemplul tău și îl aplică pe problema nouă. Eficient mai ales pe modele mai mici (Haiku 4.5, GPT-5.5 mini) unde zero-shot CoT poate să nu fie suficient.

Capcană de evitat: CoT crește numărul de tokens output. Pentru sarcini simple (clasificare, extracție) îl eviți — costă inutil. Folosește-l doar când raționamentul intermediar adaugă valoare.

2. Few-Shot Prompting: Învățare din exemple

Ce este: Furnizarea în prompt a 2-5 exemple complete de input-output, urmate de query-ul real. Modelul învață formatul și stilul din exemple.

Când o folosești: Când ai nevoie de format consistent (extrageri structurate, clasificări nuanțate, transformări de date) și descrierea cu cuvinte e ambiguă.

Exemplu real — extragere entități din contracte juridice:

Prompt:
Extrage din textul juridic părțile contractuale, suma și termenul de plată.
Format: JSON.

Exemplu 1:
Text: „Între SC ALFA SRL (vânzător) și SC BETA SA (cumpărător),
pentru suma de 50.000 RON + TVA, plătibilă în 30 zile..."
Output: {"vanzator": "SC ALFA SRL", "cumparator": "SC BETA SA",
"suma_ron": 50000, "tva_inclus": false, "termen_zile": 30}

Exemplu 2:
Text: „GAMA Consulting SRL prestează servicii pentru DELTA Industries,
contravaloare 12.500 EUR cu TVA inclus, plata în 60 de zile calendaristice..."
Output: {"prestator": "GAMA Consulting SRL", "beneficiar": "DELTA Industries",
"suma_eur": 12500, "tva_inclus": true, "termen_zile": 60}

Acum extrage din:
„OMEGA Tech SRL livrează echipamente către SIGMA Group, valoare contractuală
85.000 RON fără TVA, scadență la 45 de zile lucrătoare."

Best practices Few-Shot în 2026:

1. Exemple diverse: Acoperă cazurile margine din primele 2-3 exemple. Dacă toate exemplele tale sunt simple, modelul va eșua pe input-uri complexe.
2. Format identic: Toate exemplele trebuie să aibă exact același format (JSON, Markdown, lista) — modelul va replica.
3. Ordonare: Pentru clasificare, alternează clasele în exemple (nu pune toate „pozitiv" la rând, apoi „negativ" — bias de recency).
4. Cantitate optimă: 3-5 exemple e sweet spot. Sub 2 = inconsistent. Peste 7 = costuri inutile, randament marginal.

3. ReAct: Reasoning + Acting pentru sisteme cu acțiuni

Ce este: Pattern în care modelul alternează între raționament (Thought) și acțiune (Action), observând rezultatul (Observation) înainte de pasul următor. Bază pentru aproape toți agenții AI moderni — de la Claude Agent SDK la LangGraph.

Când o folosești: Când agentul tău are acces la tool-uri (search, calculator, API-uri, database) și trebuie să decidă dinamic care tool să apeleze și când.

Structura clasică ReAct:

Thought: [Modelul explică ce intenționează să facă]
Action: [Numele tool-ului și parametrii]
Observation: [Rezultatul tool-ului — venit din sistem]
Thought: [Următorul pas pe baza observației]
Action: [...]
...
Thought: Acum am informațiile necesare.
Final Answer: [Răspunsul final]

Exemplu real — agent care răspunde la întrebări de business:

System prompt:
Ești un asistent de business cu acces la tool-uri:
- search_internal_kb(query): caută în knowledge base intern
- query_database(sql): rulează SQL pe data warehouse
- send_slack_message(channel, text): trimite mesaj Slack

Folosește pattern ReAct: Thought → Action → Observation → ... → Final Answer.

User: Câte comenzi avem peste 10.000 RON neonorate de mai mult de 7 zile?
Trimite raportul echipei #operatiuni pe Slack.

Răspunsul agentului:
Thought: Trebuie să interoghez baza de date pentru comenzi neonorate
peste 10.000 RON și mai vechi de 7 zile.
Action: query_database("SELECT COUNT(*), SUM(valoare) FROM comenzi
WHERE valoare > 10000 AND status = 'neonorata'
AND DATEDIFF(NOW(), data_creare) > 7")
Observation: {"count": 23, "total_ron": 487500}
Thought: Am datele. Acum formatez și trimit pe Slack.
Action: send_slack_message("#operatiuni", "Avertizare: 23 comenzi
neonorate peste 10.000 RON, vechime > 7 zile. Total: 487.500 RON.")
Observation: {"status": "sent", "ts": "2026-04-28T10:23:45"}
Final Answer: Raport trimis. 23 comenzi neonorate, total 487.500 RON.

Considerații pentru producție:

• Limita de iterații: Setează max_iterations (de obicei 5-10). Fără limită, un agent poate intra în bucle infinite costisitoare.
• Timeout per Action: Tool-urile externe pot să nu răspundă. Failover graceful e obligatoriu.
• Logging fiecare Thought: Pentru audit și debugging — esențial când agentul ia decizii care afectează business-ul.
• Validare Observation: Modelul poate fi păcălit de output-uri malicioase (prompt injection prin date din tool-uri).

ReAct e baza pentru framework-uri moderne ca LangGraph, OpenAI Agents SDK, Claude Agent SDK și CrewAI. Înțelegerea pattern-ului brut îți permite să debug-uiești când abstracțiile se sparg.

4. Structured Output: Răspunsuri previzibile pentru integrare

Ce este: Forțarea modelului să răspundă într-un format strict definit (JSON cu schemă, Pydantic class, XML cu DTD), garantat de runtime-ul providerului.

Când o folosești: Mereu când răspunsul e consumat programatic — extracții, clasificări, transformări, output către alt serviciu.

Evoluția 2024 → 2026:

În 2024, structured output era „best effort" — instruai modelul să răspundă în JSON, validai cu try/catch, încercai din nou la eșec. În 2025, OpenAI a introdus Structured Outputs garantat (cu response_format și JSON Schema), iar Anthropic a urmat cu suport pentru tool use cu schema validată.

În 2026, e standard în toate API-urile majore.

Exemplu — Anthropic Claude Opus 4.7 cu schema:

import anthropic
from pydantic import BaseModel, Field

class CandidatScreening(BaseModel):
    nume_candidat: str
    scor_potrivire: int = Field(ge=0, le=100)
    competente_relevante: list[str]
    flaguri_atentie: list[str]
    recomandare: str  # "interviu" | "respins" | "lista_secundara"
    motivare: str

client = anthropic.Anthropic()
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=1024,
    tools=[{
        "name": "evaluare_candidat",
        "description": "Evaluează candidatul pe baza CV-ului și a job description-ului",
        "input_schema": CandidatScreening.model_json_schema()
    }],
    tool_choice={"type": "tool", "name": "evaluare_candidat"},
    messages=[{
        "role": "user",
        "content": f"CV:\n{cv_text}\n\nJob description:\n{jd_text}\n\nEvaluează."
    }]
)

result = CandidatScreening(**response.content[0].input)
# Garantat valid — runtime Anthropic forțează schema.

Avantaje structured output garantat:

• Zero parsing errors: Nu mai validezi output cu regex sau try/except
• Schema-driven development: Pydantic class = contract între AI și restul sistemului
• Validări tipizate: Range-uri (ge=0, le=100), enum-uri (Literal["A", "B", "C"]), formate (email, URL)
• Compatibilitate downstream: Output-ul curge direct în baza de date, API-uri, dashboard-uri

Capcană: Schema prea restrictivă poate duce la „edge cases" în care modelul forțează răspunsuri care nu se potrivesc realității. Lasă spațiu pentru nullable și optional unde e cazul.

5. Tree-of-Thought (ToT): Pentru probleme cu spațiu de soluții

Ce este: Generalizare a Chain-of-Thought în care modelul explorează multiple linii de raționament în paralel, evaluează rezultatele intermediare și alege calea cea mai promițătoare. Lansat de Princeton & DeepMind în 2023.

Când o folosești: Probleme combinatorice, planificare strategică, optimizare cu trade-off-uri multiple, design decisions complexe.

Exemplu — alegere arhitectură pentru sistem distribuit:

Prompt:
Trebuie să arhitecturezi un sistem care procesează 50.000 evenimente/sec
cu latență sub 100ms și buget cloud sub 10.000 EUR/lună.

Folosește Tree-of-Thought:
1. Generează 3 variante de arhitectură.
2. Pentru fiecare, evaluează scor 1-10 pentru: latență, scalabilitate, cost.
3. Alege varianta cu scorul total maxim.
4. Detaliază varianta câștigătoare.

Diferența ToT vs CoT:

• CoT urmează un singur lanț de gânduri.
• ToT explorează ramuri paralele, le evaluează și taie ramurile slabe (similar cu beam search în NLP clasic).

ToT e costisitor (multiplică tokens output), deci îl rezervi pentru decizii cu impact mare.

6. Self-Consistency: Validare prin majority voting

Ce este: Rulezi același prompt CoT de N ori (cu temperature > 0) și iei răspunsul care apare cel mai frecvent. Reduce erorile pe sarcini cu un singur răspuns corect.

Când o folosești: Probleme matematice, deducții logice, calcule financiare — orice sarcină unde există un răspuns „corect" verificabil.

Implementare:

def self_consistent_answer(prompt: str, n: int = 5):
    answers = []
    for _ in range(n):
        response = client.messages.create(
            model="claude-opus-4-7",
            messages=[{"role": "user", "content": prompt + "\n\nGândește pas cu pas."}],
            temperature=0.7,  # variație între rulări
        )
        answers.append(extract_final_answer(response))

    # Majority vote
    from collections import Counter
    return Counter(answers).most_common(1)[0][0]

Trade-off: Cost × N. Pentru sarcini critice (compliance, financial reporting) se justifică. Pentru chatbot UX, nu.

Cum aplici aceste tehnici în producție

Tehnicile de mai sus sunt instrumente. Combinarea lor inteligentă e adevărata artă.

Pattern recomandat pentru aplicații serioase:

1. Layer 1 — System prompt cu rolul, constrângerile, formatul output (Structured Output)
2. Layer 2 — Few-Shot pentru cazurile margine specifice domeniului
3. Layer 3 — Chain-of-Thought activat pe sarcinile complexe (cu instrucțiune explicită)
4. Layer 4 — ReAct dacă agentul are tool-uri
5. Layer 5 — Self-Consistency pentru output-uri critice

Greșelile cele mai frecvente pe care le vedem:

• Stacking necontrolat: Aplicarea tuturor tehnicilor simultan fără să măsori contribuția fiecăreia. Fă A/B testing.
• Lipsă de eval set: Construiești prompt-uri „după feeling" în loc să măsori cu un set de input-uri reprezentative și metrici clari.
• Ignorarea cost-latency trade-off: Un prompt cu CoT + Self-Consistency × 5 poate fi de 20× mai scump decât un prompt simplu. Validează că ROI există.
• Lipsă de versionare: Prompt-urile sunt cod. Stochează-le în Git, testează-le ca pe cod, deploy-uiește-le ca pe cod.

Cum te ajută cursurile Cursuri AI

Tehnicile prezentate aici reprezintă fundamentul Modulelor 4-7 din Prompt Engineering Masterclass — cursul nostru intermediate dedicat exclusiv prompt engineering pentru aplicații reale. În curs, fiecare tehnică e însoțită de:

• Exerciții practice pe Claude Opus 4.7 și GPT-5.5
• Exemple complete în Python cu API-uri Anthropic și OpenAI
• Studii de caz din producție (sisteme reale, anonimizate)
• Checklist-uri pentru evaluarea calității prompt-urilor

Pentru cei care vor să meargă mai departe — de la „știu să scriu prompt-uri bune" la „construiesc sisteme LLM în producție" — recomandăm:

1. Integrare Avansată LLM în Aplicații de Producție — function calling, structured outputs garantat, MCP, observabilitate, optimizare costuri, conformitate EU AI Act
2. AI Agents: Arhitectura și Automatizarea Sistemelor Autonome — ReAct, Plan-and-Execute, Reflexion, framework-uri moderne (LangGraph, Claude Agent SDK), securitate agenți

Toate cursurile sunt incluse în abonamentul Cursuri AI, alături de profesorul virtual AI care răspunde la întrebări tehnice direct în lecție — util când lucrezi pe un prompt real și ai întrebări concrete de implementare.

Întrebări frecvente

Care este diferența între Chain-of-Thought și Tree-of-Thought?

CoT urmează un singur fir de raționament linear. ToT explorează multiple ramuri în paralel, evaluează rezultatele intermediare și alege cea mai promițătoare cale. ToT e mai puternic pe probleme combinatorice, dar și mult mai costisitor — îl folosești selectiv.

Pot folosi aceste tehnici cu modele open-source (Llama, Mistral, DeepSeek)?

Da, toate tehnicile (CoT, Few-Shot, ReAct) sunt independente de provider. Structured Output garantat e disponibil prin librării ca Outlines, Instructor sau JSON mode în vLLM. Acuratețea pe modele open-source e însă, de regulă, mai joasă decât pe Claude Opus 4.7 sau GPT-5.5 — necesită mai mult tuning.

Cât de des trebuie să-mi reactualizez prompt-urile?

La fiecare upgrade major de model (de exemplu trecerea de la Claude Opus 4.6 la 4.7, sau de la GPT-5.4 la 5.5). Modelele noi pot avea sensibilități diferite — prompt-uri optimizate pentru versiunea anterioară pot subperforma. Bune practici: păstrează un eval set și re-rulează la fiecare schimbare de model.

Few-Shot vs Fine-tuning — când aleg fiecare?

Few-Shot pentru iterație rapidă, costuri mici, cazuri cu volum redus de date. Fine-tuning pentru când ai mii de exemple, vrei latență minimă, comportament foarte specializat și volum mare în producție. Regula de buzunar: începe cu Few-Shot, treci la fine-tuning doar când Few-Shot nu mai scalează.

Chain-of-Thought funcționează la fel pe toate modelele?

Nu. Modelele mari (Claude Opus 4.7, GPT-5.5, Gemini 3.1 Pro) au CoT „intern" îmbunătățit prin extended thinking — pot raționa fără instrucțiune explicită. Modelele mai mici (Haiku 4.5, GPT-5.5 mini, Gemini 3.1 Flash) beneficiază mai puternic de prompt-uri CoT explicite. Adaptează tehnica la model.

Concluzie

Prompt engineering avansat nu e o colecție de „trucuri secrete". E o disciplină inginerească cu principii, instrumente și metrici clari. Tehnicile prezentate aici — Chain-of-Thought, Few-Shot, ReAct, Structured Output, Tree-of-Thought, Self-Consistency — sunt fundațiile pe care companiile serioase construiesc sisteme LLM în 2026.

Diferența între un developer care „știe să folosească ChatGPT" și unul care construiește sisteme AI de producție e exact aici: în înțelegerea când și cum se aplică fiecare tehnică, în măsurarea impactului, în iterarea disciplinată cu eval sets.

Investiția în prompt engineering avansat se recuperează rapid — un sistem care răspunde corect 95% din timp în loc de 70% reduce dramatic costurile de retry, suport și remediere downstream.

Pentru parcurs structurat, complet în română, cu exemple pe modelele actuale (Claude Opus 4.7, GPT-5.5, Gemini 3.1) și profesor virtual AI care îți răspunde la întrebări concrete când lucrezi pe prompt-uri reale, vezi Prompt Engineering Masterclass — cursul nostru dedicat tehnicilor avansate pentru aplicații production-ready.