---
title: "Gemini 4 Hydrogen vs Gemini 3.8 Flash: test n=3 w CLI, złożoność kodu AST i ceny API"
slug: "gemini-4-hydrogen-vs-gemini-3-8-flash-test-porownanie"
date: 2026-11-16
description: "Porównuję Gemini 4 Hydrogen i Gemini 3.8 Flash w 3 niezależnych rundach CLI (n=3) na detektorze kanibalizacji GSC. Sprawdzam czas pracy, złożoność cyklomatyczną AST, wydajność na 100 tys. wierszy i koszty API."
author: "Jakub Krysmalski"
canonical: "https://krysmalski.pl/blog/gemini-4-hydrogen-vs-gemini-3-8-flash-test-porownanie"
tags:
  - "AI"
---

**Gemini 4 Hydrogen** jest w zadaniach programistycznych średnio **2,0x szybszy** od **Gemini 3.8 Flash** (`71,57 s` vs `143,26 s` w trzech niezależnych rundach CLI, a licząc po medianie **2,2x szybszy**: `63,93 s` vs `140,59 s`), utrzymuje ponad trzykrotnie mniejszy rozrzut czasu pracy (`±14,08 s` vs `±45,55 s`) i generuje kod o **dwukrotnie niższej maksymalnej złożoności cyklomatycznej** (`13,7` vs `27,3` wg metryki McCabe'a). W API nowy model kosztuje jednak dokładnie dwa razy więcej za milion tokenów (`1,50 USD / 7,50 USD` wobec `0,75 USD / 3,75 USD` w Gemini 3.8 Flash). Sprawdzam na twardych danych z 6 sesji terminalowych, analizie drzewa składniowego AST oraz teście wydajnościowym na 100 000 wierszy z Google Search Console, kiedy przesiadka na Hydrogena realnie się opłaca.

W poprzednim wpisie omawiałem [premierę Gemini 4 Hydrogen i Carbon oraz pierwszy pojedynek z Claude Sonnet 5.5](/blog/gemini-4-hydrogen-carbon-test-porownanie-ceny), w którym wykonałem pojedynczy przebieg (`n=1`). Pojedynczy test zawsze zostawia otwarte pytanie o losowość: czy dany model po prostu trafił na lepsze okno opóźnień po stronie serwerów Google, a błędy w warunkach brzegowych były jednorazowym wypadkiem przy pracy? Żeby to rozstrzygnąć, przygotowałem nowy, znacznie trudniejszy skrypt analityczny SEO i uruchomiłem oba modele **po trzy razy (****`n=3`****)** w odizolowanych procesach CLI `agy`.

## Czego szukają deweloperzy po premierze Gemini 4 Hydrogen? Dane z DataForSEO i Google Suggest?

Przed wyborem zadania testowego sprawdziłem w **DataForSEO** (Keyword Overview, AI Keyword Data oraz Live SERP dla rynku polskiego `2616 / pl`) i w **Google Autocomplete**, jak wygląda popyt na porównania modeli Google po premierze z 12 listopada 2026 roku.

W podpowiedziach Google Suggest dla zapytania `gemini 4 hydrogen vs` na pierwszym miejscu pojawia się już bezpośrednio fraza **`gemini 4 hydrogen vs 3.8 flash`**, a dla `gemini 3.8 flash vs` w pierwszej trójce ląduje **`gemini 3.8 flash vs 4 hydrogen`** (obok porównań z `3.1 pro` oraz `claude sonnet 5.5`). Z kolei miesięczne wolumeny bazowych fraz w polskim Google i w asystentach AI pokazują wyraźny podział intencji:

| Fraza kluczowa (Polska, `2616 / pl`) | Miesięczny wolumen Google | Wolumen w narzędziach AI (`ai_search_volume`) | Trudność (KD) | Średnie CPC (USD) | Główna intencja |
|---|---|---|---|---|---|
| **google antigravity** | **8 100** | **12** (szczyt: 18) | 66 | 2,42 USD | Informacyjna / narzędziowa |
| **gemini api** | **4 400** | **8** | 42 | 0,19 USD | Informacyjna / deweloperska |
| **gemini flash** | **1 300** | **15** | 23 | 0,86 USD | Informacyjna |
| **gemini 4** | **1 000** | **3** | 0 | 1,58 USD | Informacyjna |
| **porównanie modeli ai** | **110** | - | - | 0,80 USD | Komercyjna |
| **gemini modele** | **50** | **1** | - | - | Informacyjna |
| **gemini api cena** | **20** | - | - | - | Komercyjna |

Dane z DataForSEO pokazują dwie ważne rzeczy:

1. **Ruch wokół środowiska Google Antigravity (****`8 100`**** wyszukiwań/mies. w Polsce) przerósł już samą frazę ****`gemini api`**** (****`4 400`****)** - większość pytań o `gemini 4 hydrogen vs 3.8 flash` pochodzi dziś od osób, które widzą oba modele na liście wyboru w IDE lub w terminalu `agy` i zastanawiają się, którego używać na co dzień.
1. **Fraza ****`gemini flash`**** ma najwyższy udział zapytań bezpośrednio wewnątrz narzędzi AI (****`ai_search_volume: 15`****)** - programiści pytają czaty AI o różnice w cenie, szybkości i jakości kodu między generacją 3.8 a 4.0, zanim podejmą decyzję o podmianie identyfikatora modelu w swoich skryptach.

## Cennik API a subskrypcja Google Antigravity: gdzie leży granica opłacalności?

Zanim przejdziemy do wyników z terminala, zestawmy parametry i stawki obu modeli. Wcześniej punktem wyjścia w czwartej generacji był model opisany w tekście [Gemini 4 Argon z oknem 1M tokenów w API i AI Mode](/blog/google-zapowiada-gemini-4-argon-okno-1m-tokenow), natomiast **Gemini 4 Hydrogen** zastąpił linię 3.x jako domyślny szybki model codziennego użytku.

| Parametr | Gemini 4 Hydrogen | Gemini 3.8 Flash | Różnica (Hydrogen vs Flash 3.8) |
|---|---|---|---|
| **Identyfikator w `agy` CLI** | `gemini-4-hydrogen-{low,medium,high,xhigh}` | `gemini-3.8-flash-{low,medium,high}` | Hydrogen dodaje poziom `xhigh` (Extra) |
| **Okno kontekstowe** | 1 000 000 tokenów | 1 000 000 tokenów | Bez zmian (1M tokenów) |
| **Cena API - wejście (1M tokenów)** | **1,50 USD** | **0,75 USD** | **2,0x drożej w API** |
| **Cena API - wyjście (1M tokenów)** | **7,50 USD** | **3,75 USD** | **2,0x drożej w API** |
| **Dostęp w Google Antigravity** | Plany **Pro** oraz **Ultra** | Plany **Pro** oraz **Ultra** | Ten sam limit puli w subskrypcji |

Na papierze sytuacja dzieli się na dwa zupełnie różne scenariusze:

- **Praca w subskrypcji Google Antigravity (IDE oraz CLI ****`agy`****)**: oba modele korzystają z tej samej puli limitów konta Pro/Ultra. Nie płacisz tu od tokena, więc wygrywa model, który szybciej oddaje działający kod i rzadziej zmusza Cię do poprawiania błędów w kolejnym prompcie.
- **Potoki wsadowe w API (OpenRouter / Google AI Studio)**: u siebie w wewnętrznym systemie SEO Manager długo trzymałem `google/gemini-3.8-flash` jako domyślny model do szkiców i analizy SERP, bo przy uwzględnieniu ukrytych tokenów rozumowania (*reasoning tokens*, które w praktyce podwajają koszt wyjścia) pojedyncze wywołanie analityczne zamykało się w okolicach `0,04 - 0,08 USD`. Przejście na Hydrogena w API podwaja rachunek za tokeny, więc ma sens tylko wtedy, gdy wyższa precyzja pozwala zrezygnować z drugiego przebiegu naprawczego lub sędziego w trybie *duel*.

## Metodologia benchmarku n=3: detektor kanibalizacji GSC i 18 testów weryfikacyjnych

Żeby sprawdzić nie tylko średnią szybkość, ale też **powtarzalność wyników między uruchomieniami**, zaprojektowałem zadanie znacznie trudniejsze od prostych skryptów tekstowych. Każdy model musiał od zera napisać w czystym Pythonie (wyłącznie biblioteka standardowa: `urllib.parse`, `math`, `collections`) moduł **`gsc_cannibalization.py`** wykrywający kanibalizację słów kluczowych na podstawie surowego eksportu wierszy z Google Search Console, a także stworzyć i uruchomić własny zestaw 12 testów jednostkowych `unittest`.

Wszystkie sesje uruchomiłem przez CLI `agy` (szczegóły środowiska opisuję w poradniku o [konfiguracji Herdr z Claude Code i Google Antigravity](/blog/konfiguracja-herdr-claude-code-google-antigravity-agy)) w trzech kolejnych rundach. W każdej rundzie równolegle startowała jedna sesja `gemini-4-hydrogen-medium` oraz jedna sesja `gemini-3.8-flash-medium`:

```text
Funkcja: detect_gsc_cannibalization(rows: list[dict], site_domain: str, min_query_impressions: int = 100, min_second_share: float = 0.15) -> dict

Wymagania algorytmiczne (8 grup reguł):
1. Walidacja i odrzucanie wierszy (discarded_rows_count): puste query po strip/kolapsie białych znaków, clicks < 0, impressions <= 0, clicks > impressions, position < 1.0, schematy inne niż http/https, porty inne niż 80/443, subdomeny inne niż www. oraz domeny zewnętrzne.
2. Kanoniczna normalizacja URL: zawsze https:// + znormalizowany site_domain (małe litery, bez www. i bez portu), usunięcie końcowych ukośników "/" poza samym rootem "/", usunięcie #fragmentu, odfiltrowanie utm_* (case-insensitive), gclid, fbclid, msclkid z zachowaniem pustych wartości (keep_blank_values=True) i posortowaniem pozostałych parametrów.
3. Agregacja duplikatów (query, normalized_page): suma clicks i impressions oraz średnia pozycja ważona wyświetleniami: sum(position_i * impressions_i) / sum(impressions_i).
4. Detekcja kanibalizacji: total_impressions >= min_query_impressions, min. 2 unikalne URL-e, sortowanie URL-i po (-impressions, -clicks, url ASC), udział drugiego URL-a secondary_impressions / total_impressions >= min_second_share.
5. Wyliczenie 10 metryk dla każdego skanibalizowanego zapytania (w tym position_gap oraz severity_score = wyświetlenia poza primary_url) i posortowanie wyników po (-severity_score, query ASC).
```

Po zakończeniu wszystkich 6 sesji każdy wygenerowany moduł przepuściłem przez:

1. **Wspólny zestaw 18 testów (****`test_master_gsc.py`****)**: 15 testów sprawdzających wszystkie warunki brzegowe specyfikacji (`test_01` - `test_15`) oraz 3 testy odporności defensywnej na złośliwe dane wejściowe (`test_16`: `NaN` oraz `Inf` w `position`, `test_17`: liczby zmiennoprzecinkowe `10.5` przekazane jako `clicks`/`impressions`, `test_18`: uszkodzony nawias IPv6 `http://[::1/bad` rzucający `ValueError` wewnątrz `urlsplit`/`urlparse`).
1. **Analizę drzewa składniowego AST (****`ast`**** w Pythonie)**: pomiar liczby linii kodu bez komentarzy (`SLOC`), liczby wydzielonych funkcji, pokrycia typowaniem (`type hints`), głębokości zagnieżdżenia oraz **złożoności cyklomatycznej McCabe'a (****`CC`****)**.
1. **Test wydajności wykonania (runtime benchmark)**: pomiar czasu przetworzenia **100 000 wierszy GSC** (5 000 fraz po 20 wierszy z parametrami UTM i błędnymi rekordami) przez kod napisany przez każdy model.

## Wyniki w 3 rundach (n=3): czas wykonania, stabilność i skuteczność testów

W każdej z trzech rund **Gemini 4 Hydrogen (Medium)** skończył pisanie modułu, pliku testowego i weryfikację w terminalu wyraźnie szybciej od **Gemini 3.8 Flash (Medium)**:

| Przebieg / Statystyka | Gemini 4 Hydrogen (Medium) | Gemini 3.8 Flash (Medium) | Przewaga Hydrogena |
|---|---|---|---|
| **Runda 1 (`run_1`)** | **63,93 s** (17/18 PASS) | **99,10 s** (17/18 PASS) | **1,55x szybciej** (-35,17 s) |
| **Runda 2 (`run_2`)** | **62,95 s** (18/18 PASS) | **190,09 s** (18/18 PASS) | **3,02x szybciej** (-127,14 s) |
| **Runda 3 (`run_3`)** | **87,82 s** (17/18 PASS) | **140,59 s** (15/18 PASS) | **1,60x szybciej** (-52,77 s) |
| **Średni czas (`mean`, `n=3`)** | **71,57 s** | **143,26 s** | **Dokładnie 2,00x szybciej** |
| **Mediana czasu (`median`)** | **63,93 s** | **140,59 s** | **2,20x szybciej** |
| **Odchylenie standardowe (`σ`)** | **±14,08 s** (zakres 62,95 - 87,82 s) | **±45,55 s** (zakres 99,10 - 190,09 s) | **3,2x stabilniejszy czas pracy** |
| **Testy specyfikacji (`3 x 15`)** | **45 / 45 (100%)** | **45 / 45 (100%)** | Remis (pełna zgodność ze specyfikacją) |
| **Testy defensywne (`3 x 3`)** | **8 / 9 (88,9%)** | **5 / 9 (55,6%)** | **+33,3 pp wyższa odporność na błędy typów** |
| **Pełny zestaw Master (`3 x 18`)** | **52 / 54 (96,3%)** | **50 / 54 (92,6%)** | Mniej luk na niejawnych warunkach brzegowych |

Najważniejszy wniosek z trzykrotnego powtórzenia eksperymentu dotyczy **stabilności opóźnień (jittera)**. W dwóch z trzech przebiegów Gemini 4 Hydrogen zamknął całe zadanie w niemal identycznym czasie (`63,93 s` oraz `62,95 s`), a w najwolniejszym trzecim przebiegu potrzebował `87,82 s` - czyli wciąż mniej niż najszybszy przebieg Gemini 3.8 Flash (`99,10 s`). Z kolei w Gemini 3.8 Flash różnica między najszybszą a najwolniejszą sesją wyniosła ponad półtorej minuty (`99,10 s` vs `190,09 s`). W codziennej pracy z agentem w terminalu oznacza to, że na Flashu 3.8 trudno przewidzieć, czy na wynik poczekasz półtorej minuty, czy ponad trzy.

## Złożoność cyklomatyczna (AST) i wydajność na 100 000 wierszy: jak oba modele piszą kod?

Sam wynik testów jednostkowych nie mówi jeszcze wszystkiego o tym, jak będzie się utrzymywać wygenerowany kod. Kiedy przepuściłem wszystkie 6 plików `gsc_cannibalization.py` przez parser drzewa składniowego `ast`, wyszła na jaw bardzo wyraźna, powtarzalna w każdej rundzie różnica w architekturze kodu między generacją 4.0 a 3.8:

| Metryka jakości i złożoności kodu (średnia z `n=3`) | Gemini 4 Hydrogen (Medium) | Gemini 3.8 Flash (Medium) | Co to oznacza w praktyce? |
|---|---|---|---|
| **Linie kodu bez komentarzy (`SLOC`)** | **149,3** (`147`, `153`, `148`) | **182,7** (`181`, `198`, `169`) | Hydrogen pisze o **18,3% bardziej zwięzły kod** przy tej samej funkcjonalności |
| **Liczba wydzielonych funkcji** | **5,0** (w każdym z 3 przebiegów `5`) | **3,0** (w każdym z 3 przebiegów `3`) | Hydrogen zawsze wydziela osobne helpery walidacji metryk i zapytań |
| **Pokrycie adnotacjami typów (`type hints`)** | **100%** (`5/5` funkcji w każdym przebiegu) | **100%** (`3/3` funkcji w każdym przebiegu) | Oba modele konsekwentnie typują sygnatury funkcji |
| **Łączna złożoność cyklomatyczna (`Total CC`)** | **41,0** (`42`, `41`, `40`) | **50,3** (`51`, `51`, `49`) | Kod Flasha 3.8 ma o **22,7% więcej rozgałęzień decyzyjnych** |
| **Max złożoność pojedynczej funkcji (`Max CC`)** | **13,7** (`14`, `13`, `14`) | **27,3** (`26`, `28`, `28`) | Hydrogen mieści się w normie linterów (`CC <= 15`), Flash tworzy monolit (`CC 26-28`) |
| **Czas wykonania 100 000 wierszy GSC (mediana)** | **454,9 ms** (`413,2 - 532,5 ms`) | **497,4 ms** (`389,5 - 638,9 ms`) | W 3. rundzie kod Flasha zwolnił do **638,9 ms** przez `re.sub` w pętli |

Skąd bierze się aż dwukrotna różnica w maksymalnej złożoności cyklomatycznej pojedynczej funkcji (`13,7` vs `27,3`) oraz rozbieżności w testach defensywnych?

1. **Dekompozycja na 5 funkcji vs monolityczna pętla (****`Max CC 13-14`**** vs ****`26-28`****)**: we wszystkich trzech przebiegach (`3/3`) Gemini 4 Hydrogen zaprojektował identyczną, czystą strukturę modułu z pięcioma funkcjami: `_normalize_domain`, `_normalize_query`, `_normalize_page`, `_is_valid_metrics` oraz główną `detect_gsc_cannibalization`. Dzięki temu żadna funkcja nie przekroczyła złożoności cyklomatycznej `14` (standardowy próg ostrzegawczy `C901` w narzędziach `ruff` i `flake8` wynosi `15`). Gemini 3.8 Flash w każdym z trzech przebiegów (`3/3`) upchnął całą walidację typów, zakresów liczbowych i czyszczenie `query` bezpośrednio wewnątrz pętli głównej `detect_gsc_cannibalization`, windując jej złożoność do `26 - 28`.
1. **Idiomatyczny Python 3.10+ zamiast rozwlekłych warunków**: do obcięcia prefiksu `www.` i normalizacji ścieżki URL Hydrogen w każdym przebiegu użył zwięzłych konstrukcji `host.lower().removeprefix("www.")` oraz jednoliniowego `path = parsed.path.rstrip("/") or "/"`. Flash 3.8 pisał w tym miejscu 8-liniowe drzewo `if/else` z ręcznym wycinaniem indeksów `host[4:]`.
1. **Pułapka ****`float("nan") < 1.0`**** w Pythonie (****`test_16`****)**: w Pythonie każde porównanie mniejszości lub większości z wartością `NaN` zwraca `False`. Jeśli w danych wejściowych pojawi się uszkodzony float `position: float("nan")`, warunek `if position < 1.0:` go nie zatrzyma. Gemini 4 Hydrogen w dwóch z trzech przebiegów sam z siebie zaimportował moduł `math` i dodał strażnika `if math.isnan(position) or math.isinf(position): return False`.
1. **Błąd typów i wydajności w 3. przebiegu Flasha (****`gsc_flash_3`****)**: w trzeciej rundzie Gemini 3.8 Flash użył warunku `not isinstance(clicks, (int, float))`, przez co zamiast odrzucać błędne wiersze ze zmiennoprzecinkową liczbą kliknięć (`clicks: 10.5`), po cichu obcinał je przez `int(clicks)`. W tym samym przebiegu zastosował też `re.sub(r"\s+", " ", ...)` wewnątrz głównej pętli zamiast szybkiego `" ".join(query.split())` oraz cięższe `urlparse` zamiast `urlsplit` bez bloku `try/except ValueError`. Na próbce **100 000 wierszy GSC** taki kod wykonywał się w **`638,9 ms`** wobec **`413,2 ms`** w drugim przebiegu Hydrogena (spadek wydajności wygenerowanego skryptu o ponad 54%).

## Zestawienie zbiorcze z 3 różnych zadań SEO: `seo_slug.py`, `seo_audit.py` i `gsc_cannibalization.py`

Jeżeli połączymy dzisiejszy, trzyrundowy benchmark (`n=3`) z dwoma zadaniami z poprzedniego testu, otrzymujemy pełny obraz zachowania obu modeli w łącznie **10 sesjach terminala CLI**:

| Zadanie testowe w CLI `agy` | Liczba przebiegów | Czas: Gemini 4 Hydrogen (Medium) | Czas: Gemini 3.8 Flash (Medium) | Skok szybkości | Jakość kodu i testy brzegowe |
|---|---|---|---|---|---|
| **1. Generator sluga (`seo_slug.py`)** | `n=1` | **34,27 s** | 82,35 s | **2,40x szybciej** | Oba modele 100% PASS (Hydrogen sam dodał walidację `max_len <= 0`) |
| **2. Parser HTML SEO (`seo_audit.py`)** | `n=1` | **50,49 s** | 185,10 s | **3,67x szybciej** | Hydrogen **12/12 PASS (100%)**, Flash **9/12 PASS** (3 błędy na `#fragment` i `<base href>`) |
| **3. Detektor kanibalizacji GSC (`gsc_cannibalization.py`)** | `n=3` (6 sesji) | **71,57 s** (mediana **63,93 s**) | 143,26 s (mediana 140,59 s) | **2,00x - 2,20x szybciej** | Specyfikacja: oba **45/45 PASS**; pełny zestaw z testami defensywnymi: **52/54 vs 50/54**; Max CC: **13,7 vs 27,3** |

Moim zdaniem te trzy testy bardzo dobrze pokazują, na czym polega przesunięcie generacyjne między linią 3.8 a 4.0. Nawet kiedy wymusimy w obu modelach identyczny poziom rozumowania (`Medium`) i damy im bardzo szczegółową specyfikację, **Gemini 4 Hydrogen** nie tylko kończy pracę ponaddwukrotnie szybciej, ale przede wszystkim **pisze bardziej zdyscyplinowany architektonicznie kod** - dzieli logikę na mniejsze funkcje pomocnicze, pilnuje złożoności cyklomatycznej i rzadziej zapomina o obronie przed nietypowymi wartościami wejściowymi (`NaN`, `bool` będący podklasą `int` w Pythonie czy uszkodzone adresy URL).

## Kiedy zostać na Gemini 3.8 Flash, a kiedy przełączyć się na Gemini 4 Hydrogen?

Na Twoim miejscu podzieliłbym wykorzystanie obu modeli według prostego kryterium środowiskowego i kosztowego:

1. **W Google Antigravity (IDE oraz CLI ****`agy`**** na planach Pro i Ultra) przełącz się na stałe na Gemini 4 Hydrogen** - w abonamencie nie płacisz stawki per token, a zyskujesz średnio dwukrotnie krótszy czas oczekiwania na odpowiedź, ponad trzykrotnie mniejszy rozrzut czasowy między sesjami i znacznie czytelniejszy podział kodu na funkcje. Do codziennych zadań deweloperskich poziom `Medium` wystarcza z nawiązką, a przy trudniejszej architekturze zawsze masz w odwodzie domyślny poziom `High` lub `XHigh`.
1. **W masowych potokach API bez generowania kodu zostaw Gemini 3.8 Flash tam, gdzie liczy się niska stawka za token** - przy prostej klasyfikacji wyników SERP, wyciąganiu nagłówków konkurencji czy streszczaniu długich tekstów stawka `0,75 USD / 3,75 USD` za milion tokenów w Flashu 3.8 nadal robi dokładnie tę samą robotę za połowę ceny Hydrogena (`1,50 USD / 7,50 USD`).
1. **W potokach API generujących kod lub złożone struktury JSON wybierz Gemini 4 Hydrogen mimo 2x wyższej ceny za token** - w zadaniach z wieloma warunkami brzegowymi wyższa dyscyplina typów i niższa złożoność cyklomatyczna Hydrogena oznaczają mniej nieudanych walidacji schematu i brak konieczności ponawiania zapytań, co w praktyce wyrównuje wyższą stawkę cennikową.

Jeśli budujesz w swojej firmie narzędzia SEO, integrujesz potoki danych z Google Search Console i DataForSEO albo chcesz zoptymalizować koszty i architekturę agentów AI w swoim zespole - napisz do mnie przez formularz kontaktowy na stronie, chętnie pomogę zaprojektować i przetestować takie rozwiązanie na Twoich danych.

## Często zadawane pytania (FAQ)

### Czy Gemini 4 Hydrogen zużywa więcej limitu (quota) w subskrypcji Google Antigravity niż Gemini 3.8 Flash?

W środowisku Google Antigravity (CLI `agy` w wersji `1.5.7` na planie Pro) oba modele korzystają ze wspólnej puli zapytań odnawianej cyklicznie. Podczas przeprowadzenia 6 pełnych sesji benchmarkowych (3 rundy po 2 modele wraz z zapisem plików i uruchomieniem testów) łączne zużycie puli wyniosło około 2% limitu.

### Dlaczego w teście sprawdzaliśmy `isinstance(clicks, bool)` skoro `clicks` ma być liczbą całkowitą `int`?

W Pythonie typ logiczny `bool` dziedziczy bezpośrednio po klasie `int` (`issubclass(bool, int)` zwraca `True`, a `True == 1` oraz `False == 0`). Bez jawnego wykluczenia `isinstance(x, bool)` funkcja walidująca przepuściłaby wartość `clicks: True` jako poprawną liczbę `1`. Zarówno Gemini 4 Hydrogen, jak i Gemini 3.8 Flash prawidłowo zabezpieczyły ten warunek we wszystkich przebiegach.

### Jaki poziom rozumowania (thinking level) wybrać w Gemini 4 Hydrogen do codziennego kodowania w CLI?

Domyślnym ustawieniem modelu Gemini 4 Hydrogen jest poziom `High`, jednak w zadaniach obejmujących pojedynczy moduł i zestaw testów jednostkowych (ok. 150-200 linii kodu) poziom `Medium` osiąga 100% skuteczności na specyfikacji przy średnim czasie pracy około 64-72 sekund. Poziomy `High` oraz `XHigh` warto rezerwować dla wieloplikowej refaktoryzacji i trudnych błędów współbieżności.

## Źródła

- Google DeepMind: [Introducing Gemini 4 Hydrogen](https://blog.google/technology/google-deepmind/introducing-gemini-4-hydrogen/)
- Google AI for Developers: [Gemini API Pricing](https://ai.google.dev/gemini-api/docs/pricing)
- DataForSEO API Documentation: [DataForSEO Labs & AI Optimization API](https://docs.dataforseo.com/v3/)

---

*Wpis pochodzi z serwisu [krysmalski.pl](https://krysmalski.pl/blog/gemini-4-hydrogen-vs-gemini-3-8-flash-test-porownanie)*
