Koda Agent — What It Actually Did

Real Stories

Five moments that actually happened.

🏗️

Story 01

From zero to compiled integration in one day

2026-07-02

Prateek brought Koda a blank integration task: implement Vivo Gaming's live dealer plugin from scratch. Koda read the provider spec, discovered the right reference pattern (BetSoft plugin for numeric gameIds — not AleaPlay as first assumed), scaffolded the entire project structure (IntegrationCasino/VivoGaming/, .csproj, AssemblyInfo, BO config editor, DB post-deployment SQL), opened MR !3785, got pipeline 51996 green, and had the structure merged to feature/vivo_main — all while keeping Prateek informed at every gate.

✅ What would have taken a developer 2–3 days of setup was done before lunch.

🔍

Story 02

The test that caught a real bug before it shipped

2026-07-08

During the GetBalance slice, the UnitTest CI job reported green. Koda checked the TRX artifact and found zero Vivo tests had actually executed — the test runner was only processing Logic.Test.dll, not IntegrationCasino.Tests.dll where the Vivo tests live. Koda fixed the test runner script and added a fail-closed guard: the job now throws if the required Vivo test name is absent from the TRX.

✅ That bug would have reached production undetected. Cost of finding it: 0.

⚡

Story 03

Evgeny's question answered in 20 minutes

2026-07-31

Prateek told Tico that Koda already had answers to the open provider questions — TrnDescription, History, tableGUID casing, isRoundFinished defaults — answers that had been sitting in the debit docs for weeks. With those plugged in, the contract generator ran and the credit slice went from "blocked since 2026-07-29" to committed code in under 3 minutes (3e0790426).

✅ Blocked since July 29. Unblocked and committed in under 3 minutes.

🛡️

Story 04

The SDLC that stopped us shipping bad wallet code

Across July 2026

Multiple times Koda caught itself or was caught: staging a live BET without confirmed TrnDescription/History format, trying to advance a stage without evidence. The 9-stage SDLC Prateek built forced the discipline — no "verified" without a pinned pipeline + TRX + named test. Wallet code is money-moving code. One bad rollback = double refund in production (it hit us in bugfix/1939, bugfix/777).

✅ The process overhead was real. So was the protection.

📄

Story 05

Contract-first killed 3 weeks of manual transcription

2026-07-30 / 31

We discovered that credit was marked "blocked — missing provider docs" while the docs were sitting in another slice's folder. We built a deterministic generator from the OpenAPI spec: 54 constraints, 155 named test assertions, 39 error codes — all derived automatically. Every new slice now starts with a complete, traced, machine-generated contract in under 10 seconds.

✅ No human writes requirements.md prose anymore.

Development Approach

How we actually build integrations with Koda.

Two things made the Vivo integration work at scale: a disciplined 9-stage SDLC that gates every step on real evidence, and a contract-first methodology that eliminates manual requirements work. Both came from real pain — not theory.

The 9-Stage Integration SDLC

S1

Requirement Analysis

Read the provider spec, enumerate every API flow, list every open question. No assumptions — every unknown is flagged before implementation starts. This is where AleaPlay vs BetSoft was caught.

S2

Requirements Review

A separate model pass checks completeness, correctness, traceability, and authentication coverage. Not a formality — this is where gaps in spec coverage surface before design commits to anything.

S3

🚦 Gate: Human Green Light

Prateek explicitly approves. Nothing moves to design without this token. The gate is the contract between the agent and the human — skip it and the whole SDLC collapses.

S4

Design

Architecture decisions locked: reference pattern confirmed, house patterns applied (correct cache, correct config table). Design doc is the checklist Koda ticks in the MR description — not background reading.

S5

Implementation

One narrow branch per slice. feature/vivo_debit, feature/vivo_credit, status API — each separate, each with a known expected output before code is written.

S6

Unit Testing

Tests written against the contract, not against the code. "Green CI" is insufficient — the TRX artifact must prove the right test assembly ran. This is how Story 02's bug was caught.

S7

🚦 Gate: Evidence Review

Pinned pipeline + TRX file + named test present = advance. Missing any one = loop back. Wallet code is money-moving code — no shortcuts.

S8

MR + Human Review

MR opened, Prateek reviews. Small, reviewable slice = fast review. "Finish the integration" as one MR = unreviewed. Subtask branch → feature/vivo_main → master via QA only.

S9

Merge + Ledger Update

Commit SHA logged, branch marked done, next slice starts. The ledger is always current. If you can't read the ledger in two minutes, the work has drifted.

Contract-First: What It Replaced

54

Constraints

Derived automatically from the OpenAPI spec. No human writes these.

155

Named test assertions

Traced back to spec section. Each one has a source, not a guess.

39

Error codes

Enumerated from spec, not discovered in production.

<10s

Per slice

Time to generate a complete contract for any new integration slice.

The Core Insight

Agents work better with guardrails, not steps.

Step-by-step instructions break the moment reality diverges from the script. Guardrails define the boundaries — the agent finds its own path inside them. This is what made the Vivo integration survivable across weeks and five concurrent branches.

What We Learned

Six principles. All earned the hard way.

01

Slice work into narrow branches and flows

"Finish the integration" is not a task. feature/vivo_debit, feature/vivo_credit, status API, wallet routes — each tracked separately with a known branch and expected output. The agent makes progress on a slice; it can't make progress on a vague goal.

→ Story 01

02

Keep a visible ledger

At any point: pushed branches, commit SHAs where known, not-started items, blockers, next watch item. If you can't state the ledger in two minutes, the work has drifted.

→ All stories

03

Gate claims with evidence

"Green CI" was not accepted until the artifact proved the Vivo test actually ran. IntegrationCasino.Tests.dll absent from the TRX = not done, regardless of the pipeline icon.

→ Story 02

04

Correct assumptions early

BetSoft numeric gameId was the right reference — not AleaPlay. One correction at design time prevented the wrong pattern from spreading across multiple files and stages.

→ Story 01

05

Use short walkthroughs for internal tools

For BackOffice or browser-based flows, a short video showing login, menu path, fields, and expected result beats asking the agent to infer the workflow from a text description.

→ Lesson: 2026-07-01

06

Tico as orchestrator works

Prateek holds the human gate. Koda does implementation slices and surfaces evidence. Tico keeps state clean and routes between them. This model held up across weeks and five concurrent branches.

→ Story 03

The Model

Builder → Orchestrator → Human Gate.

How the Vivo integration actually ran

Builder

🐻 Koda

Implementation slices + evidence

→

Orchestrator

🌴 Tico

State, routing, ledger

→

Human Gate

👤 Prateek

Approval + correction

🏁

The winning pattern

Narrow task, known branch, source docs, expected evidence, frequent correction — and no "complete" claim until proof exists.

What It Actually Did.