How We Work with AI at Eskube

Eskube AI Standard · v0.1 · May 2026

Applies to all roles, all projects, all AI tools. No code, no tool-specific references.

1. Principles

Three principles govern every decision about how we design and use AI.

Keep It Simple (KISS)

Start with the simplest statement of the problem. Let the solution emerge from the problem — not from your expectations about what it will look like.

State what you want to achieve, not how you think it should be built
Prefer a script over a microservice, a flat file over a database — until complexity is forced on you
Every layer of complexity is a layer to test, debug, document, and maintain

Wrong: "I need Poetry, FastAPI, Pydantic, an async middleware stack, and a pipeline that..."
Right: "I want to flag anomalies in safety reports. Where do we start?"

Don't Repeat Yourself (DRY)

Every piece of logic has one authoritative home.

If you find yourself copying and pasting, extract and reference instead
Duplicated logic is the primary source of silent inconsistency
This applies to AI prompts too — shared prompt blocks should be centralised, not copy-pasted across tasks

You Aren't Gonna Need It (YAGNI)

Build what the problem requires today. Not what it might require.

Do not design for hypothetical future requirements
AI tools generate generalised implementations by default — review and remove what you don't need
KISS + DRY + YAGNI together: write the minimum correct solution, avoid duplication, do not speculate

2. When to Use AI

Use AI only where human judgment is genuinely needed. Use deterministic code everywhere else.

flowchart LR
    IN([Input]) --> PARSE
    subgraph DET_IN ["Deterministic — precise, auditable"]
        PARSE["Parse & validate\nfails loudly on bad input"]
    end
    PARSE --> AI
    subgraph AI_WORK ["AI — only where reasoning is needed"]
        AI["Classify · Reason · Generate"]
    end
    AI --> GEN
    subgraph DET_OUT ["Deterministic — precise, auditable"]
        GEN["Format & output"]
    end
    GEN --> OUT([Output])

Deterministic code handles parsing, validation, and output formatting — it cannot hallucinate
AI stages handle classification, reasoning, and generation — only where rule-based logic cannot
Mixing them carelessly produces fragile systems: a prompt change can silently break output structure

Design for degradation from day one:

Mode	Behaviour
`ai`	Full pipeline — AI reasoning enabled
`heuristic`	Template-based output — no AI cost
`skeleton`	Structure only — no content

A tool that requires a live API call to function is unreliable exactly when reliability matters most.

3. Human-in-the-Loop

For consequential outputs, human approval is architecture — not a UX feature.

flowchart LR
    IN([Input]) --> S1["AI stage"]
    S1 --> G1{"👤 Human\nreview"}
    G1 -- "Approved" --> S2["AI stage"]
    G1 -- "Rejected / corrected" --> S1
    S2 --> G2{"👤 Human\nreview"}
    G2 -- "Approved" --> OUT([Output])
    G2 -- "Rejected / corrected" --> S2

AI fills the steps between gates. Humans own the gates.
Stage outputs must be editable before approval — the operator must not be locked into the model's first draft
The question is not "did the AI produce an answer?" but "did a human verify this before it left the system?"

You are a gate, not a passenger. Approving AI output without reading it is not oversight — it is delegation without accountability.

4. Quality and Auditability

Define what "correct" looks like before you build. Log everything after.

Before you build: - Write a test that defines the expected behaviour — then build to make it pass - Curate a small set of representative inputs with known-correct outputs (20–30 is enough to start) - Define your accuracy baseline at design time — not after

After you build: - Log every AI call: model, prompt version, tokens in/out, cost, latency, timestamp - Run your reference set on every significant change — prompt update, model version, schema change - Low accuracy is a signal about where the system needs improvement — not necessarily a failure

Always review AI output before accepting it. AI tools optimise for plausible-looking output, not verified correctness. Your review is the last check.

Eskube AI Standard · v0.1 · May 2026
To propose changes: open a PR against eskube-ai-standard.