leestijd : 22 minutes

Men vraagt me vaak hoeveel mijn AI-gebruik kost. Ik antwoord: '20 ballen per maand' en men kijkt me aan met grote ogen. Dus vandaag open ik voor jullie de zwarte doos. Dit artikel is het volledige audit van mijn 73 dagen vibe coding: de methodologie om de gegevens te extraheren uit de SQLite-database van OpenCode, de SQL-code om de tabellen te bevragen, en de uitgebreide vergelijking met alle leveranciers op de markt — westers als Chinees. Het resultaat is zo asymmetrisch dat ik mijn berekeningen drie keer moest controleren.

De stack begrijpen: Wie doet wat?

Voordat we in de cijfers duiken, laten we de architectuur verduidelijken. Er zijn drie verschillende actoren in mijn setup, en het is belangrijk om ze niet te verwarren:

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontSize 12

title De Drie Actoren van Mijn Stack LLM
left to right direction

actor "Ik (Ontwikkelaar)" as Dev

package "OpenCode\n(github.com/anomalyco/opencode)" as OC {
  rectangle "CLI van vibe coding\nOpen source, gratis" as CLI
  note right of CLI
Dit is het hulpmiddel dat ik gebruik
voor te coderen met AI‑agents.
Het biedt geen AUCUN model.
Dat is een terminal + een orchestrator
  end note
}

package "Ollama (Lokale installatie)" as OL {
  rectangle "Inferentieclient\nGeïnstalleerd op mijn machine" as Client
  note right of Client
Het is de software die draait
Modellen. Hij kan ze uitvoeren
lokaal OF delegeren naar de cloud
op basis van het tag (:cloud).
Hij authentiseert met behulp van sleutel SSH
  end note
}

package "Ollama Cloud\n(ollama.com)" as OCloud {
  rectangle "Cloud-inferentieservice\nPro-abonnement : 20€/mois" as Cloud
  note right of Cloud
Dit is de inferentieaanbieder.
Mijn modellen met de tag :cloud
worden uitgevoerd op LEURS servers.
Het Pro-abonnement geeft toegang
aan hogere quota.
  end note
}

Dev --> CLI : "Ik typ prompts"
CLI --> Client : "Roep dit model aan"
Client --> Cloud : "Sleutel SSH + vraag\n(modellen :cloud)"
Client --> Client : "Lokale uitvoering\n(modellen zonder :cloud)"

@enduml

OpenCode is NIET een leverancier van modellen.Dit is een open source CLI (github.com/anomalyco/opencode) die AI-agents orchestreert. Hij verkoopt geen abonnement en levert geen inferentie. Dit is het equivalent van`git`voor versiebeheer: een hulpmiddel, geen dienst. Ollama Cloud is de inferentieprovider.Mijn lokale Ollama-installatie fungeert als client — ze authenticeren bij de Ollama-servers via een unieke SSH-sleutel (Device Key) en delegeert de uitvoering van de gelabelde modellen aan hen.:cloud. Pro-abonnement (20 €/maand) ontgrendelt hogere quoteringen en maakt het mogelijk om meerdere accounts op één machine te combineren via Docker.

Inleiding: Waarom een audit?

Twee maanden geleden gebruikte ik gratis modellen op mijn lokale Ollama-installatie. Daarna sloot ik een eerste abonnement af op Ollama Cloud Pro van 20 euro per maand, waardoor ik de cloudmodellen kan gebruiken (die met de tag`:cloud`) via de provider`ollama-cloud`. Een tweede abonnement volgde een maand later op een gescheiden Docker-instantie met zijn eigen account en eigen SSH-sleutel — de cumulatieve methode beschreven in mijn artikel over het stapelen van abonnementen

De vraag die me bezighield : Zijn deze 20 € per maand gerechtvaardigd? Niet op gevoel. Met cijfers.

Om te antwoorden, had ik precieze gegevens nodig. Geen schattingen. Geen gemiddelden. Mijn echte consumptie, token per token, model per model, sessie per sessie.

En OpenCode — de CLI — slaat dit alles op in een SQLite-database.

De OpenCode-database: Een goudmijn

OpenCode slaat de volledige geschiedenis van zijn sessies op in een SQLite-bestand dat zich bevindt op`~/.local/share/opencode/opencode.db`. La mienne pèse 660 Mo pour 73 jours d’utilisation — une base de données de production tout à fait respectable.

$ ls -lh ~/.local/share/opencode/opencode.db
-rw-r--r-- 1 cheroliv cheroliv 660M mai 18 12:25 opencode.db

Het schema

De database bevat ongeveer twintig tabellen, maar drie daarvan zijn cruciaal voor onze audit :

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontSize 12

title Vereenvoudigd schema — OpenCode SQLite
entity "sessie" as S {
  * id : TEXT
  --
  * model : TEXT (JSON)
  * cost : REAL
  * tokens_input : INTEGER
  * tokens_output : INTEGER
  * tokens_reasoning : INTEGER
  * tokens_cache_read : INTEGER
  * tokens_cache_write : INTEGER
  * time_created : INTEGER
  * project_id : TEXT
}

entity "bericht" as M {
  * id : TEXT
  --
  * session_id : TEXT <<FK>>
  * data : TEXT (JSON)
  * time_created : INTEGER
}

entity "project" as P {
  * id : TEXT
  --
  * worktree : TEXT
  * name : TEXT
}

S ||--o{ M : "session_id"
S }o--|| P : "project_id"

note right of S
De sessietabel aggregeert tokens + kosten + model.
Dit is ons belangrijkste ingangspunt.
end note

note right of M
De individuele berichten.
Het data‑veld bevat het gebruikte model (format JSON)
zelfs als de sessie van model verandert onderweg
end note

@enduml

De tafel`session`is perfect voor een globale audit: elke sessie heeft zijn geaggregeerde aantal tokens, zijn gebruikte model en zijn kosten. Het veld`model`is ruwe JSON :

{
  "id": "deepseek-v4-pro:cloud",
  "providerID": "ollama-cloud",
  "variant": "default"
}

Het veld`cost`in de OpenCode-database weerspiegelt alleen de externe API-kosten betaald per gebruik via API-sleutel (Google Gemini, OpenAI, enz.). De aanroepen via Ollama — zowel lokaal als via Ollama Cloud Pro — zijn gemarkeerd`cost=0`omdat de kosten vastliggen (abonnement), niet per-token. De echte kosten van deze gesprekken zijn het maandelijkse abonnement.

De extractiecode

Je hoeft niets te installeren. Node.js 22+ bevat een experimenteel SQLite-module (node:sqlite) die perfect werkt. Dit is het script dat mij alles heeft gegeven:

const { DatabaseSync } = require('node:sqlite');
const db = new DatabaseSync(
  `${process.env.HOME}/.local/share/opencode/opencode.db`,
  { readonly: true }
);

// 1. Statistiques globales
const global = db.prepare(`
  SELECT
    COUNT(*) as sessions,
    SUM(tokens_input) as total_input,
    SUM(tokens_output) as total_output,
    SUM(tokens_reasoning) as total_reasoning,
    SUM(tokens_cache_read) as total_cache_read,
    SUM(cost) as total_cost
  FROM session
`).get();

// 2. Ventilation par modèle et fournisseur
const byModel = db.prepare(`
  SELECT
    json_extract(model, '$.id') as model_id,
    json_extract(model, '$.providerID') as provider,
    COUNT(*) as sessions,
    SUM(tokens_input) as total_input,
    SUM(tokens_output) as total_output,
    SUM(cost) as total_cost
  FROM session
  WHERE model IS NOT NULL
  GROUP BY model_id, provider
  ORDER BY SUM(tokens_input) DESC
`).all();

// 3. Par mois
const monthly = db.prepare(`
  SELECT
    strftime('%Y-%m', datetime(time_created/1000, 'unixepoch')) as month,
    COUNT(*) as sessions,
    SUM(tokens_input) as total_input,
    SUM(tokens_output) as total_output,
    SUM(cost) as total_cost
  FROM session
  WHERE time_created IS NOT NULL
  GROUP BY month
  ORDER BY month
`).all();

// 4. Messages par modèle (détection des changements intra-session)
const msgByModel = db.prepare(`
  SELECT
    json_extract(m.data, '$.model.providerID') as provider,
    json_extract(m.data, '$.model.modelID') as model_id,
    COUNT(*) as messages
  FROM message m
  WHERE json_extract(m.data, '$.model') IS NOT NULL
  GROUP BY provider, model_id
  ORDER BY COUNT(*) DESC
`).all();

console.log({ global, byModel, monthly, msgByModel });
db.close();

De vlag`--experimental-sqlite`Op Node.js 22.x is vereist. Op Node.js 24+ is het module stabiel en vereist geen vlag meer.

De Resultaten : 73 Dagen van Consumptie

Globale weergave

metriek Waarde Context

Sessions OpenCode

1 022

~14 sessies/dag gemiddeld

Tokens invoer

2,62 miljard

Waarvan 94,5M cache-hit

Tokens Output

21 miljoen

Ratio input/output ~125:1

Tokens Reasoning

141 000

Verwaarloosbaar — bijna geen thinking

Kosten externe API

$0,22

Kosten buiten abonnement (Gemini + gratis niveaus)

Dit bedrag van \$0,22 is cruciaal: het vertegenwoordigt alles wat ik heb betaald naast mijn Ollama Cloud Pro-abonnement. Dat wil zeggen, bijna niets. Het abonnement dekt het essentiële.

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontSize 12

title Maandelijkse evolutie — invoer tokens
rectangle "Maart 2026\n9 sessies\n37,7M tokens" as MARS #FFE082
rectangle "April 2026\n486 sessies\n1,33 Md tokens" as AVR #81C784
rectangle "Mei 2026\n527 sessies\n1,25 Md tokens" as MAI #64B5F6

MARS -right-> AVR : ×35
AVR -right-> MAI : stable (huidige periode)

note bottom of MAI
Mei geteld tot en met de 18e.
Projectie volledige maand: ~2,1 Md tokens
als de trend zich voortzet.
end note
@enduml

De lancering tussen maart en april is spectaculair: ×35 in één maand. Dit is de overgang van gebruik « test » naar gebruik « productie » — toen ik begon om OpenCode-agents continu te laten draaien voor mijn Gradle-plugins.

Ventilatie per model en leverancier

Het veld`model`van de tafel`session`zijnde JSON,`json_extract()`maakt het mogelijk om schoon te ventileren:

Model × Provider Sessies Input Output Kosten

deepseek-v4-pro @ ollama-cloud

63

220 M

1,94 M

\$0

deepseek-v4-pro @ ollama-b

124

463 M

4,15 M

\$0

deepseek-v4-pro @ ollama

100

252 M

2,25 M

\$0

deepseek-v4-flash-free @ opencode

16

1,3 M

279 K

\$0

qwen3.6-plus-free @ opencode

1

369 K

25 K

\$0

gemini-2.5-flash @ google

1

211 K

19 K

\$0,04

Drie verschillende providers voor exact hetzelfde model DeepSeek V4 Pro: * ollama-cloud→ via betaald Pro-abonnement (cloud beheerd door Ollama) * ollama-b→ tweede Pro-abonnement, geïsoleerd in een aparte Docker-container * ollama`instance native locale, gratis (draait rechtstreeks op mijn machine) De som van de drie bedraagt 936M input, 8,4M output — dit is mijn totale verbruik DeepSeek V4 Pro, alle providers samen. Alleen`ollama-cloud(220M input) kost een abonnement. De resterende 716M zijn gratis (lokaal of een combinatie van abonnementen).

Intra-Sessie-modellen: Wat de Sessietabel niet ziet

De tafel`session`ne vangt alleen het hoofdmodel van de sessie. Maar tijdens dezelfde sessie kan een OpenCode-agent schakelen tussen meerdere modellen. De tabel`message`het onthult:

Modèles utilisés dans les messages (ollama-cloud provider) :
├─ deepseek-v4-pro      1 441 msgs  (32%)
├─ qwen3.5:397b         1 217 msgs  (27%)
├─ glm-5.1                712 msgs  (16%)
├─ kimi-k2.6:cloud        634 msgs  (14%)
├─ qwen3-coder:480b       414 msgs   (9%)
├─ gpt-oss:20b             34 msgs  (0,8%)
├─ qwen3-coder-next        27 msgs  (0,6%)
└─ gemma4:31b               7 msgs  (0,2%)

Ik gebruik niet meer Qwen, GLM, Kimi noch de andere modellen. Ze verschijnen in de geschiedenis omdat ik heel wat dingen heb getest in april. Sinds half mei ben ik geblokkeerd op DeepSeek V4 Pro — het is het enige dat de belasting aankan bij lange contexte met agent governance (cf. mijn vergelijking Kimi/GLM/DeepSeek). De 32% deepseek-berichten in de geschiedenis zijn misleidend: vandaag is het 100%.

Tariefvergelijking — Westerse leveranciers

De brandende vraag: hoeveel zou dezezelfde consumptie kosten bij traditionele leveranciers?

Mijn berekeningsbasis voor de vergelijking:220M tokens invoer + 1,9M tokens uitvoer— alleen het volume dat is gepasseerd`ollama-cloud`(de enige die overeenkomt met mijn betaalde abonnement). De resterende 716M zijn gratis (lokale Ollama en Docker B-instantie).

leverancier model \$/M $/M Kosten/maand × mijn abonnement

Mijn setup

DeepSeek V4 Pro

0

0

\~20€

1×

Anthropic — Claude

Model $/M Uitvoer $/M Kosten/maand × mijn abonnement

Opus 4.7

\$5

\$25

\$1 148

57 keer

Sonnet 4.6

\$3

\$15

\$689

34 keer

Haiku 4.5

\$1

\$5

\$230

11×

Zelfs Haiku 4.5, het meest 'kostenefficiënte' model van Claude, kost 11× mijn abonnement. En het kent niets van mijn codebase, genereert niet in mijn stijl, en hallucineert over de Gradle Kotlin DSL-APIs.

OpenAI — GPT

Model $/M Output $/M Kosten/maand × mijn abonnement

GPT 5.5

\$5

\$30

\$1 157

58×

GPT 5.4

\$2,50

\$15

\$579

29×

GPT 5.4 Mini

\$0,75

\$4,50

\$174

9 keer

Google — Gemini

Model \$/M Uitvoer \$/M Kosten/maand mijn abonnement

Gemini 3.1 Pro

\$2,00

\$10

\$459

23×

Gemini 3 Flash

\$0,30

\$1,50

\$69

3,5×

Gemini 3 Flash van 69€ is de enige « dichtbij » concurrent in puur prijs — maar het is een lichtgewicht dicht model, geen MoE 1.6T zoals DeepSeek V4 Pro. De kwaliteit van de gegenereerde code heeft niets te maken.

HuggingFace Inferentie-aanbieders

HuggingFace voert zelf geen inferentie uit — het agregateert externe providers (Novita, Together, DeepInfra, Cerebras, SambaNova, Fireworks, Groq…) via een geïntegreerde API. Men kiest de provider die het goedkoopst of het snelst is. Hier zijn de tarieven die in mei 2026 zijn vastgelegd voor DeepSeek V4 Pro :

Leverancier HF $/M Uitvoer \$/M Kosten/maand × mijn abonnement

Novita (het goedkoopst)

\$1,67

\$3,38

\$374

19×

DeepInfra

\$1,74

\$3,48

$389

19×

Samen

\$2,10

\$4,40

$470

23×

vuurwerk

niet openbaar tarief

—

—

—

Zelfs de goedkoopste provider op HuggingFace (Novita) vraagt 19× de prijs van mijn abonnement. En in tegenstelling tot Ollama Cloud rekent HuggingFace ook de platformkosten als je geen PRO HF-abonnement hebt ($9/maand).

Groq

Groq heeft geen van de modellen die ik gebruik — hun catalogus beperkt zich tot GPT-OSS, Llama en Qwen 32B. Onmogelijk te vergelijken.

Tariefvergelijking — Chinese leveranciers

De echte test is de Chinese markt. Als DeepSeek een Chinees model is, zou zijn native API goedkoper moeten zijn, niet?

DeepSeek API Direct (platform.deepseek.com)

periode \$/M Uitvoer \$/M Kosten/maand

Promo -75% (eind 31 mei)

\$0,435

\$0,87

\$98

Vol tarief (vanaf juni)

\$1,74

\$3,48

\$390

Zelfs met de agressieve promotie van DeepSeek (-75% verlengd), kost de directe API5×duurder. Bij het normale tarief,20 keer. En het is alleen DeepSeek — geen toegang tot andere modellen.

Kimi Moonshot (platform.kimi.com)

Kimi biedt alleen zijn eigen modellen aan. Geen DeepSeek.

Alibaba Bailian (bailian.aliyun.com)

Enkele leverancier die alle Chinese modellen aggregeert — maar via doorverkoop met marge. De prijzen worden dynamisch geladen in JavaScript, waardoor scraping onmogelijk is.

Samenvattende tabel — Alle Providers

Leverancier model $/M Output $/M Kosten per maand × mijn abonnement

Ollama Cloud Pro

DeepSeek V4 Pro

0

0

~20€

1×

Gemini 3 Flash

Gemini 3 Flash

\$0,30

\$1,50

\$69

3,5×

DeepSeek API (promotie)

DeepSeek V4 Pro

\$0,44

\$0,87

\$98

5×

GPT 5.4 Mini

GPT 5.4 Mini

\$0,75

\$4,50

\$174

9×

Claude Haiku 4.5

Claude Haiku 4.5

\$1

\$5

\$230

11×

HuggingFace/Novita

DeepSeek V4 Pro

\$1,67

\$3,38

\$374

19×

DeepSeek API (normaal)

DeepSeek V4 Pro

\$1,74

\$3,48

\$390

20×

Samen AI

DeepSeek V4 Pro

\$2,10

\$4,40

\$470

23×

GPT 5.4

GPT 5.4

\$2,50

\$15

\$579

29×

Claude Sonnet 4.6

Claude Sonnet 4.6

\$3

\$15

\$689

34×

Claude Opus 4.7

Claude Opus 4.7

\$5

\$25

\$1 148

57×

GPT 5.5

GPT 5.5

\$5

\$30

\$1 157

58×

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontSize 11

title Verwachte Maandelijkse Kosten — 220M Input + 1,9M Output
rectangle "Ollama Cloud Pro\n~20€" as OC #4CAF50
rectangle "Gemini Flash\n\$69" as GF #8BC34A
rectangle "DeepSeek promo\n\$98" as DSP #FFC107
rectangle "GPT Mini\n\$174" as GM #FF9800
rectangle "Claude Haiku\n\$230" as CH #FF5722
rectangle "HF/Novita\n\$374" as HF #F44336
rectangle "DeepSeek normal\n\$390" as DSN #F44336
rectangle "GPT 5.4\n\$579" as G4 #D32F2F
rectangle "Claude Sonnet\n\$689" as CS #D32F2F
rectangle "Claude Opus\n\$1 148" as CO #B71C1C
rectangle "GPT 5.5\n\$1 157" as G5 #880E4F

note bottom of OC
DeepSeek V4 Pro 1.6T MoE
+ toegang tot de volledige catalogus
Ollama Cloud (Qwen, GLM, Kimi...)
Inbegrepen in het abonnement
end note
@enduml

De Verborgen Kosten : Prompt Engineering en Iteraties

De tokenkosten zijn slechts een deel van de vergelijking. De echte kosten zijn de ontwikkelertijd.

Met OpenCode + Ollama Cloud Pro + mijn bestuur agent (EAGER/LAZY/Hot/Warm/Cold, beschreven in het artikel over de bestuur), ik krijg :

  • 0 prompt engineering repetitief: de context wordt automatisch geïnjecteerd

  • 90%+ correct bij eerste pogingde code compileert in één keer

  • Nul hallucinatie deepseek bij 8 opeenvolgende sessies(gedocumenteerd in de vergelijking Kimi/GLM/DeepSeek)

Met Claude of GPT zonder fine-tuning of governance :

  • 2-3 iteraties per taak gemiddeld

  • Systematisch prompt engineering

  • Hallucinaties over de Kotlin/Gradle API’s zodra de context 30K tokens overschrijdt

De effectieve maandelijkse kosten — tokens × iteraties × correctietijd — zijn 27× tot 54× die van mijn oplossing, zoals ik heb aangetoond in het artikel over de efficiëntieratio.

_ Het is niet alleen een kwestie van prijs per token. Een Claude Opus die 57× duurder is en 3× meer iteraties vereist, heeft een effectieve kosten die ~170× hoger is. Om het ronduit te zeggen: een stagiaire betalen met het salaris van een McKinsey-partner. _

De Ollama Cloud Pro-abonnementen combineren: de Docker-methode

Als één abonnement niet voldoende is, combineren we ze. Het principe is om elk abonnement te isoleren in zijn eigen Ollama-installatie, met zijn eigen SSH-authenticatiesleutel. Docker maakt het triviaal.

De volledige methode wordt gedetailleerd beschreven in het artikel over het combineren van Docker, hier is het principe :

@startuml
skinparam backgroundColor #FEFEFE
skinparam defaultFontSize 12

title Architectuur — Twee Ollama Cloud Pro-abonnementen op Eén Machine
left to right direction

node "Mijn Fysieke Machine" {
  frame "Ollama Instantie A (native)\npoort :11434" as Native {
    database "Identiteit A\n/usr/share/ollama/.ollama/id_ed25519"
  }
  frame "Ollama Instantie B (Docker)\npoort :11435" as Docker {
    database "Identiteit B\n~/ollama-b-data/id_ed25519"
  }
}

cloud "Ollama Cloud" {
  actor "Pro Account A\n(email 1)" as A
  actor "Pro Account B\n(email 2)" as B
}

Native --> A : "Device Key A"
Docker --> B : "Device Key B"

note bottom of Docker
Geïsoleerde Docker-container:
- Afzonderlijke SSH-sleutel
- Afzonderlijke netwerkpoort (11435)
- Persistent volume (~/ollama-b-data)
- restart: always
end note
@enduml

Het patroon is simpel:

  1. Een volume maken`~/ollama-b-data`

  2. Een Docker-container starten`ollama/ollama:0.20.2`gemapt op`11435:11434`

  3. Ophalen van de SSH-sleutel van de container → opslaan op ollama.com

  4. doen`ollama signin`met een tweede e-mail

  5. OpenCode configureren met twee providers (`ollama`op :11434,`ollama-b`op :11435)

Twee rekeningen, één blauwe kaart, geen conflicten.

Wat de audit niet meet

dode hoek impact

Kwaliteit van de geproduceerde code

2,6 miljard tokens zeggen niet of de code compileert. Mijn 8 sessies DeepSeek V4 Pro hebben een first-shot slagingspercentage >90%.

ecosysteem OpenCode

De CLI is gratis, maar de waarde (agents, sandboxes, geschiedenis, prompt caching) is enorm. Het is niet inbegrepen in de prijs van het abonnement — het is een apart hulpmiddel.

alternatieve kosten

2 uur per dag besteden aan het debuggen van hallucinaties van een inferieur model kost meer dan €20 per maand.

Gemoedsrust

Vast tarief = geen verrassing. Met per-token kan een piek in activiteit ernstig pijn doen.

De genoemde prijzen zijn die van mei 2026. Over zes maanden zal alles zijn gedaald. Maar de structurele krachtverhouding — vast abonnement versus betalen naar gebruik — blijft gunstig voor het abonnement voor grote verbruikers.

Conclusie: Het verdict van de cijfers

Na 73 dagen, 1.022 OpenCode-sessies, en 2,6 miljard tokens :

Metrisch vonnis

Cumulatieve externe API-kosten

$0,22(bijna nul)

Abonnementskosten Ollama Cloud Pro

~20€/maand

Claude Opus-equivalent

\$1 148/maand— 57× duurder

Equivalent GPT 5.5

$1 157/maand— 58 keer duurder

Gelijkwaardig HuggingFace/Novita

\$374/maand— 19× duurder

Direct DeepSeek API-equivalent

$390 per maand— 20× duurder

Goedkoopste equivalent

$69/maand— 3,5× duurder, lager model

beste aanbod op de markt

Ollama Cloud Pro voor 20€/maand— onverslaanbaar

__ Voor 20€ per maand om toegang te krijgen tot DeepSeek V4 Pro (1.6T params, MoE, CSA+HCA, 1M context) via Ollama Cloud, heb ik de beste prijs-kwaliteitverhouding op de wereldwijde markt. Zelfs de rechtstreekse Chinese leveranciers zijn 5× tot 20× duurder. Zelfs HuggingFace, met zijn aggregatie van low-cost providers, is 19× duurder. De westerse markt (Claude, GPT) ligt op 50-60× — een hele andere wereld.

Deze verhouding is zo ongebalanceerd dat hij niet eeuwig kan duren. Geniet ervan zolang het bestaat. __

Dus ja, mijn 20 euro per maand, dat is de beste technische investering in mijn leven als ontwikkelaar. En nu heb je de cijfers om dat te bewijzen.


Gerelateerde artikelen