Trust-by-Design for AI Developer Tools

avalur.github.io/talks/TrustIntelligence.html

Alex Avdiushenko

aleksandr.avdiushenko@jetbrains.com

How to Build Trust?

Euclid (≈300 BC)

Trust through explicit premises: small set of postulates → all geometry

Hilbert's Program (1920s)

The ambition of "cast-iron" trust: Completeness, Consistency, and Algorithmic Decidability!

Let's ask ourselves: how can we build trust in general? I suggest thinking about trust in mathematics to start communication. Actually, math tried trust-by-design long before software. We call it axioms.
And Euclid from Alexandria was the first to formulate a system of postulates with an attempt to prove that geometry can be trusted. Euclid is the man who turned geometry from a bag of tricks into a trust engine in the 3rd century Before Christ Era: starting from a few postulates to a whole universe of beautiful conclusions.
He compiled in the Elements what we would now call a proof SDK: definitions, axioms, lemmas, theorems — assembled smoothly from simple to complex. His genius wasn’t “discovering formulas” but the architecture of reasoning: showing how a vast, consistent world can grow from a tiny set of rules. Euclid built a system of postulates that led to the proof of all two-dimensional geometry.
Now we move on to David Hilbert. He not only formulated the 23 problems in maths of the 20th century in Paris he also introduced Hilbert spaces, and developed a program twenty years later in 1920 to prove the consistency of the whole mathematics. The lifelong dream of Hilbert was to establish one formal system that’s complete, consistent, and decidable at the same time. The system which we can truly trust to.

Cold Shower of Gödel's Theorems

"Theorem 1: Any consistent formal system F within which a certain amount of elementary arithmetic can be carried out is incomplete; i.e., there are statements of the language of F which can neither be proved nor disproved in F."

"Theorem 2: For any consistent system F within which a certain amount of elementary arithmetic can be carried out, the consistency of F cannot be proved in F itself."

Kurt Gödel (1931)

But maybe you know the devastating result of another mathematician: in 1931 Gödel showed: no single system can be both powerful and complete — actually it can’t certify its own consistency. That time it was a shock to the mathematicians and computer scientists worldwide. The sad fact is that Gödel lived with severe anxiety and later even paranoid delusions. At the end of his life these led to self-starvation. He ate only what his wife Adele had previously tried. When she herself became seriously ill and could not take care of him, he died eventually in Princeton. Calling it ‘madness’ is a bit misleading: his professional reasoning remained extraordinarily sharp for decades despite illness. So he had the combination of genius and mental disorders. Gödel taught us that there is no "single switch of trust": we need layers - external meta-checks, independent evaluations, and architectures that can recognize problems and roll back.

Then How to Build Trust in AI?

"Probabilistic Logics and the Synthesis of Reliable Organisms from Unreliable Components."

John von Neumann (1952)

Pivot to architecture: cumulative hierarchies, external verification

JetBrains' Way: Trust-by-Design in Dev Tools

IDE: Secure and Effective Defaults
IDEA2025.2

We are going to talk about trust-by-design in developers' work. The first old plain layer is the IDE with all the syntax and error highlighting, with type checkings inside for almost any programming language, compiler and a bunch of code autocompletions, created long before the AI era. On one and the same interface you can see a new layer, where coding agent Junie lives. It writes code for you autonomously, does all the heavy lifting, but we need interface to communicate with, check it and to take full responsibility for the final result.

Building Resilience: Data → Model → Deploy

📊 Data (contracts, evals, coverage)

Schema contracts: typed datasets + versions; enforce in PR via Qodana checks
Drift/poison eval sets: store "golden" evals in Git repo; run regular data-evals in TeamCity pipelines
Synthetic edge-case coverage: generate rare examples (fuzz/synthetic) and publish reports as build artifacts within Datalore

🤖 Model (guardrails, decoding, spec IO)

Guardrails before/after: input/output validators in Qodana as policy-as-code for prompts/functions
Constrained decoding: temperature/top-p caps by environment; "abstain" paths mapped directly from IDE ( /) to integration tests
Spec-driven function calling: strictly typed tool-schemas; autogen test fixtures from specifications in TeamCity jobs

Building Resilience is not one trick for sure, it's layer upon layer. The first layer is Data: we hold data shape via schemas and versions as contracts. Qodana in PR stops drift, TeamCity runs regular data-evals, Datalore helps quickly build synthetic coverage for rare cases.
Now let's switch to the second layer with models. We must validate input/output and function calls, should constrain decoding and add "hallucinations" as a normal outcome. And of course, we need to test the model itself completely. So tests are written and set up in CI/CD processes.

🚀 Deploy (safe release, fast rollback)

Canary & shadow: multi-stage rollouts via TeamCity (staging → small % canary → full); metrics and alerts in YouTrack
Circuit breakers: automatic model shutdown on SLO degradation (latency/quality) — feature flags toggled from TeamCity tasks
Rollbacks & model feature flags: model versioning as artifacts; instant rollback and A/B in TeamCity pipeline; rollback policy documented in Git

And the third stage is Deploy. We must release carefully: shadow/canary in stages via TeamCity, metrics tied to triggers. If quality or latency degrades — circuit breaker and instant rollback. Model is a versioned artifact with feature flags. In total, we have an end-to-end recipe: contract data → managed models → safe deploy.
And it definitely works! We have a reliable system and for example, coding agent Junie, that users like and trust. Our AI assistant penetration overpassed Copilot a few months ago and continues to grow. And of course there will be more intelligent services from JetBrains, and they are as reliable and as effective as possible now, at the current moment.