Budowanie aplikacji z Gemini 3.1 Pro: Przewodnik dla programistów po API, kodowaniu i vibe codingu

19 lutego 2026 — Gemini 3.1 Pro właśnie zadebiutował i jest jednym z najpotężniejszych dostępnych modeli do kodowania: 80,6% w SWE-Bench Verified, 2887 Elo w LiveCodeBench oraz okno kontekstowe 1 mln tokenów w cenie 2 USD za milion tokenów wejściowych. To najwyższa wydajność za ułamek ceny.

Ten przewodnik jest przeznaczony dla programistów, którzy chcą zacząć budować rozwiązania z jego użyciem już dziś. Omówimy konfigurację API, przykłady kodu w Pythonie i Node.js, poziomy myślenia, buforowanie kontekstu w celu optymalizacji kosztów oraz sposób, w jaki Gemini 3.1 Pro wpisuje się w przepływy pracy typu vibe coding.

---

Pierwsze kroki

Opcja 1: Google AI Studio (Darmowe, bez konfiguracji)

Najszybszy sposób na wypróbowanie Gemini 3.1 Pro:

1. Przejdź do aistudio.google.com
2. Zaloguj się na swoje konto Google
3. Wybierz Gemini 3.1 Pro Preview z rozwijanego menu modeli
4. Zacznij wpisywać prompty

AI Studio jest darmowe z limitami przepustowości — idealne do prototypowania i eksperymentów.

Opcja 2: Klucz API (Do budowania aplikacji)

1. W AI Studio przejdź do Get API Key → Create API Key
2. Bezpiecznie przechowuj klucz (nigdy nie umieszczaj go w systemie kontroli wersji)
3. Zainstaluj SDK:

# Python
pip install google-genai

# Node.js
npm install @google/genai

---

Twoje pierwsze wywołanie API

Python

from google import genai

client = genai.Client(api_key="YOUR_API_KEY")

response = client.models.generate_content(
    model="gemini-3.1-pro-preview",
    contents="Write a Python function that finds the longest common subsequence of two strings. Include type hints and docstring."
)

print(response.text)

Node.js

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: "YOUR_API_KEY" });

const response = await ai.models.generateContent({
  model: "gemini-3.1-pro-preview",
  contents: "Write a TypeScript Express middleware that validates JWT tokens and extracts user info.",
});

console.log(response.text);

Z poziomami myślenia (Thinking Levels)

# High thinking for complex debugging
response = client.models.generate_content(
    model="gemini-3.1-pro-preview",
    contents="""
    This Go server has a race condition that causes intermittent 500 errors
    under load. Here's the relevant code:

    [paste your code here]

    Find the race condition and explain the fix.
    """,
    config={
        "thinking_config": {"thinking_level": "HIGH"}
    }
)

---

Kodowanie z Gemini 3.1 Pro

Kontekst benchmarków

Zanim przejdziemy do możliwości, oto jak Gemini 3.1 Pro wypada na tle innych modeli do kodowania:

Benchmark	Gemini 3.1 Pro	GPT-5.3-Codex	Claude Opus 4.6
SWE-Bench Verified	80.6%	76.2%	72.6%
Terminal-Bench 2.0	68.5%	77.3%	—
LiveCodeBench Pro	2887 Elo	—	—

Jest to 15% poprawa w stosunku do najlepszych wyników Gemini 3 Pro Preview, przy użyciu mniejszej liczby tokenów wyjściowych dla uzyskania lepszych rezultatów.

Generowanie kodu

Gemini 3.1 Pro generuje kod o jakości produkcyjnej w wielu językach. Okno kontekstowe o rozmiarze 1 mln tokenów oznacza, że możesz dołączyć swoją istniejącą bazę kodu, aby generowanie było świadome kontekstu:

# Load your codebase context
with open("codebase_context.txt", "r") as f:
    codebase = f.read()

response = client.models.generate_content(
    model="gemini-3.1-pro-preview",
    contents=f"""
    Here is my current codebase:

    {codebase}

    Add a new API endpoint POST /api/users/bulk-import that:
    - Accepts a CSV file upload
    - Validates each row against the User schema
    - Inserts valid records in batches of 100
    - Returns a summary of successes and failures
    - Follow the existing patterns and coding style
    """,
    config={
        "thinking_config": {"thinking_level": "MEDIUM"}
    }
)

Debugowanie

Wprowadź logi błędów, stack trace'y i kod źródłowy jednocześnie. Wysoki poziom myślenia (High) jest wart dodatkowego kosztu w przypadku złożonych błędów:

response = client.models.generate_content(
    model="gemini-3.1-pro-preview",
    contents="""
    Error: Connection pool exhausted after 30 seconds
    Stack trace:
    [paste stack trace]

    Relevant source files:
    [paste db.py, connection_pool.py, api_handler.py]

    This only happens under concurrent requests (>50 rps).
    Find the root cause.
    """,
    config={
        "thinking_config": {"thinking_level": "HIGH"}
    }
)

Przegląd kodu (Code Review)

Średni poziom myślenia (Medium) zapewnia zrównoważone recenzje bez nadmiernego analizowania trywialnego kodu:

response = client.models.generate_content(
    model="gemini-3.1-pro-preview",
    contents=f"""
    Review this pull request diff for:
    1. Bugs or logic errors
    2. Security vulnerabilities (SQL injection, XSS, etc.)
    3. Performance issues
    4. Adherence to project conventions

    Diff:
    {diff_content}
    """,
    config={
        "thinking_config": {"thinking_level": "MEDIUM"}
    }
)

---

Przewaga okna kontekstowego 1 mln tokenów

Okno kontekstowe o rozmiarze 1 miliona tokenów w Gemini 3.1 Pro zmienia sposób interakcji z kodem. Zamiast podawać fragmenty, możesz załadować całe projekty.

Odniesienie do rozmiaru kontekstu

Co możesz załadować	Przybliżona liczba tokenów
Pojedynczy plik (500 linii)	~2 tys. tokenów
Mały projekt (50 plików)	~100 tys. tokenów
Średni projekt (200 plików)	~400 tys. tokenów
Duży projekt (500 plików)	~1 mln tokenów

Analiza całej bazy kodu

import os

def load_codebase(root_dir, extensions=('.py', '.js', '.ts', '.jsx', '.tsx')):
    """Load all source files into a single context string."""
    files = []
    for dirpath, _, filenames in os.walk(root_dir):
        for filename in filenames:
            if any(filename.endswith(ext) for ext in extensions):
                filepath = os.path.join(dirpath, filename)
                with open(filepath, 'r', errors='ignore') as f:
                    content = f.read()
                files.append(f"=== {filepath} ===\n{content}\n")
    return "\n".join(files)

codebase = load_codebase("./src")

response = client.models.generate_content(
    model="gemini-3.1-pro-preview",
    contents=f"""
    Analyze this entire codebase and identify:
    1. Architectural issues or anti-patterns
    2. Dead code that can be removed
    3. Functions that should be refactored
    4. Missing error handling at system boundaries

    Codebase:
    {codebase}
    """
)

Jest to coś, czego po prostu nie da się zrobić z modelami o kontekście 200 tys. bez dzielenia tekstu i utraty kontekstu między plikami.

---

Poziomy myślenia: Niski, Średni, Wysoki

Poziomy myślenia pozwalają kontrolować kompromis między kosztem a jakością dla każdego zapytania.

Poziom	Przypadki użycia	Narzut tokenów	Wpływ na koszt
Niski (Low)	Autouzupełnianie, proste wyszukiwanie, formatowanie, klasyfikacja	Minimalny	~1x
Średni (Medium)	Przegląd kodu, podsumowanie, umiarkowana analiza, generowanie treści	Umiarkowany	~2-3x
Wysoki (High)	Złożone debugowanie, wieloetapowe rozumowanie, decyzje architektoniczne	Znaczny	~5-10x

Praktyczne wytyczne

• Niski: „Konwertuj ten JSON na interfejs TypeScript” — głębokie rozumowanie nie jest potrzebne.
• Średni: „Przejrzyj ten PR pod kątem błędów i luk bezpieczeństwa” — wymaga analizy, ale nie wyczerpującej.
• Wysoki: „Ten system rozproszony ma błąd spójności pod obciążeniem. Oto 15 plików…” — wymaga głębokiego rozumowania na wielu plikach.

# Switch thinking level based on task complexity
def ask_gemini(prompt, complexity="medium"):
    levels = {"low": "LOW", "medium": "MEDIUM", "high": "HIGH"}

    return client.models.generate_content(
        model="gemini-3.1-pro-preview",
        contents=prompt,
        config={
            "thinking_config": {"thinking_level": levels[complexity]}
        }
    )

---

Optymalizacja kosztów

Buforowanie kontekstu (Context Caching)

Jeśli Twoja aplikacja wielokrotnie odpytuje tę samą bazę kodu lub dokumentację, buforowanie kontekstu obniża koszty wejściowe o 75%:

Cennik	Standardowy	Zbuforowany
Wejście (za 1 mln tokenów)	2,00 USD	0,50 USD
Wyjście (za 1 mln tokenów)	12,00 USD	12,00 USD

# Create a cached context for your codebase
cached_content = client.caches.create(
    model="gemini-3.1-pro-preview",
    contents=[{"role": "user", "parts": [{"text": codebase}]}],
    ttl="3600s"  # Cache for 1 hour
)

# Subsequent queries use the cached context
response = client.models.generate_content(
    model="gemini-3.1-pro-preview",
    contents="Find all SQL injection vulnerabilities in this codebase",
    cached_content=cached_content.name
)

Porównanie kosztów dla workflow kodowania

Zakładając 500 tys. tokenów kontekstu bazy kodu + 1 tys. zapytania, 100 zapytań dziennie:

Strategia	Koszt dzienny
Gemini 3.1 Pro (bez buforowania)	~$100
Gemini 3.1 Pro (z buforowaniem)	~$27
Claude Opus 4.6 (bez buforowania)	~$750

Więcej wskazówek optymalizacyjnych

1. Dobieraj poziomy myślenia: Używaj niskiego dla 80% zadań, średniego dla 15% i wysokiego dla 5%.
2. Grupuj podobne żądania: Łącz zadania przeglądu kodu, aby zamortyzować ładowanie kontekstu.
3. Agresywnie buforuj: Jeśli odpytujesz te same dokumenty/kod więcej niż 3 razy, zbuforuj je.
4. Używaj Gemini 3 Flash do prostych zadań, które nie wymagają rozumowania na poziomie Pro.

---

Vibe Coding z Gemini 3.1 Pro

Vibe coding to praktyka polegająca na opisywaniu tego, co chcesz osiągnąć, w języku naturalnym i pozwalaniu AI na wygenerowanie kodu. Gemini 3.1 Pro jest tutaj szczególnie mocny, ponieważ rozumie intencję projektową, a nie tylko składnię.

Jak Gemini rozumie „vibe”

Zespół Hostinger zauważył, że Gemini 3.1 Pro przekłada „kierunek, styl i intencję produktu” na kod. Poproszony o zbudowanie strony portfolio o mrocznym, literackim charakterze, model przeanalizował atmosferę, aby zaprojektować pasujący interfejs.

Generowanie SVG

Wyjątkowa funkcja: Gemini 3.1 Pro generuje animowane pliki SVG bezpośrednio z opisów tekstowych. Ponieważ SVG to kod, pozostają one ostre w każdej rozdzielczości:

response = client.models.generate_content(
    model="gemini-3.1-pro-preview",
    contents="""
    Create an animated SVG logo for a tech startup called "Pulse AI".
    Design requirements:
    - Minimalist, modern style
    - Blue-to-purple gradient
    - Subtle pulse animation on the icon
    - 200x60px viewport
    - Clean, sharp edges
    """
)

# Save the SVG directly
with open("logo.svg", "w") as f:
    f.write(response.text)

Budowanie pełnych aplikacji

Połącz siłę kodowania Gemini 3.1 Pro z kreatorem aplikacji AI, takim jak NxCode, aby przejść od pomysłu do wdrożonej aplikacji:

1. Opisz swoją aplikację w języku naturalnym.
2. Gemini wygeneruje bazę kodu (frontend + backend + baza danych).
3. Przeglądaj i iteruj za pomocą promptów vibe coding.
4. Wdróż bezpośrednio do produkcji.

Ten workflow jest szczególnie potężny, ponieważ okno kontekstowe Gemini 1 mln tokenów może pomieścić całą Twoją rosnącą bazę kodu podczas kolejnych iteracji.

---

Integracja z platformami

GitHub Copilot

Gemini 3.1 Pro jest już dostępny w GitHub Copilot:

1. Otwórz ustawienia GitHub Copilot.
2. Wybierz Gemini 3.1 Pro z listy modeli.
3. Korzystaj z autouzupełniania w linii i czatu jak zwykle.

Gemini CLI

Dla programowania opartego na terminalu:

# Install
npm install -g @anthropic-ai/gemini-cli

# Use
gemini --model gemini-3.1-pro-preview "Refactor this function to use async/await"

# Pipe code in
cat src/server.js | gemini --model gemini-3.1-pro-preview "Review this code"

VS Code

Dostępny poprzez rozszerzenie Copilot. Wybierz Gemini 3.1 Pro w rozwijanym menu modeli dla sugestii w linii i czatu.

Google Antigravity

Platforma Google do programowania agentowego z głęboką integracją Gemini. Najlepsza do budowania złożonych, wieloetapowych agentów AI, którzy wymagają użycia narzędzi i długotrwałych przepływów pracy.

---

Porady i najlepsze praktyki

1. Zacznij od poziomu myślenia Medium, przechodząc na High tylko w razie potrzeby — oszczędza to 3-5x tokenów.
2. Ładuj pełny kontekst na początku — Gemini dobrze radzi sobie z 1 mln tokenów; nie filtruj danych zbyt agresywnie.
3. Używaj buforowania kontekstu dla każdej powtarzalnej analizy (przegląd kodu, pytania do dokumentacji, generowanie testów).
4. Bądź precyzyjny co do formatu wyjściowego — „Zwróć tylko kod, bez wyjaśnień” oszczędza tokeny wyjściowe.
5. Połącz z Gemini 3 Flash w systemie dwupoziomowym: Flash do prostych uzupełnień, Pro do złożonego rozumowania.
6. Dołączaj przykłady w swoich promptach — Gemini 3.1 Pro świetnie naśladuje wzorce.
7. Określaj wyraźnie język i framework — „Napisz w TypeScript przy użyciu Next.js 15 z App Router”.
8. Przeglądaj wygenerowany kod — 80,6% w SWE-Bench robi wrażenie, ale to nie 100%. Zawsze testuj i sprawdzaj kod.

---

Podsumowanie

Gemini 3.1 Pro daje programistom możliwości kodowania na najwyższym poziomie w przystępnej cenie. Okno kontekstowe o rozmiarze 1 mln tokenów to prawdziwy przełom w analizie na poziomie całej bazy kodu, a poziomy myślenia zapewniają precyzyjną kontrolę nad kosztem i jakością.

Aby dowiedzieć się więcej o tym, jak AI zmienia programowanie, sprawdź nasz przewodnik po vibe codingu oraz porównanie Cursor vs Windsurf vs Claude Code. Pełne zestawienie możliwości Gemini 3.1 Pro poza kodowaniem znajdziesz w naszym kompletnym przewodniku.