How it works, in depth
The same story as the homepage, with the detail a tech lead wants: what your developers actually see, how it all connects, and exactly what it costs. Plain enough for a CEO, precise enough for engineering.
What you actually see
Conventions and canonical examples surface as you type, pulled from your studio’s shared knowledge, not guessed.
1#include "DoTAbility.h"23// New damage-over-time ability4void ADoTAbility::Apply(AActor* Target)5{6 ApplyDamage(Target, TickDamage);7}
Abilities in this module extend UStudioGameplayAbility, not UGameplayAbility. Use the studio base class so buff-stacking and replication work out of the box.
A clear description, the right ticket link, the right reviewers, drafted for you. You confirm; nothing submits without you.
Proposed changelist description
The basics are already handled, so the review your tech lead opens is about the decisions that actually need judgment.
Per-team spend, budgets, and cache efficiency in one place, so the AI budget is never a surprise.
API spend · this month
€612
of €800 budget
Reviews run
1,847
auto post-submit
Cache hit rate
91%
prompt caching
Weekly API spend
Spend by team
The flow
Two seconds of preparation on your machine, then a deeper review runs on a server without holding you up. The dashed step is the only moment AI is involved.
The five layers
Layers reinforce each other rather than repeat each other. Hover any layer for the full deployment detail.
Convention adherence and canonical examples surfaced while code is being written.
Prevention. The developer’s AI assistant knows your studio’s conventions, canonical examples, and architectural constraints while code is being written. Convention violations are avoided at write-time, not caught at review-time.
Deterministic linter runs on save. Fast, focused, zero AI.
Linters excel at formatting, naming, and pattern rules that do not require judgment. We do not ask AI to do what a linter does better and cheaper. Millisecond feedback, zero tokens, always local.
Pre-submit hook validates and drafts the metadata around the submit, description, ticket linkage, reviewers.
Not the code itself, the metadata around it. Correct CL description (often generated from the diff and ticket), correct ticket linkage, correct reviewers assigned automatically based on file ownership. Path safety and scope coherence checked. Developer stays in control.
Cross-file impact, architectural drift, similar patterns, structured for the tech lead.
Runs asynchronously on a server-side worker after a changelist lands. Tech leads do not need AI to tell them the code compiles. They need structured analysis of impact, drift, and pattern consistency so their review time focuses on architectural judgment. Posted to Swarm, GitHub, or your review tool.
Pattern recognition surfaces knowledge-layer updates. Documentation drift detected and repaired.
The layer where the system improves itself. Weekly cron jobs plus build-failure events. Patterns that appear repeatedly become knowledge updates. Documentation drift gets flagged. Build failures generate hypothesis-driven fix proposals, never applied automatically.
Human in the loop, always
No layer autonomously modifies code. AI proposes, engineers decide. This is not a philosophical preference. It is operational necessity. Game development produces edge cases where obvious fixes create subtle regressions. Tech leads approve every code change originating from automation.
Two kinds of AI access
Your studio uses AI two ways, and they are billed differently. This holds at every major vendor.
Seats
for developersEach developer has a commercial AI seat and runs a coding assistant on their workstation. When they want help writing code, they get it through this seat. Fixed monthly cost per developer, unlimited use within reasonable rate limits, human always in the loop.
API
for automationA server-side worker calls the vendor’s API directly when events happen, a submit lands, a build fails, a scheduled analysis runs. Uses an API key, not a seat. Per-token pricing, predictable, designed for 24/7 machine access and structured output.
Why the split exists
Seats and API keys are different products designed for different uses. Seats assume a human at a keyboard: session-based auth, rate limits sized for interactive use, conversational streaming output. API keys assume server-side automation: long-lived credentials, volume rate limits, structured output guaranteed by schema, terms of service that explicitly permit programmatic access. Using seats for server-side automation would work briefly, then fail at scale and potentially violate terms of service. Using API for interactive developer work would work but cost significantly more than seats for the same volume. Each mode is used where it fits.
Submit-time, in depth
Layer 3 is not another code review, Layer 1 handles quality as you write, Layer 4 handles depth after. This layer handles everything around the code.
What it verifies
Description generation
AI writes the description from the diff and the ticket. Developer confirms or edits before submit proceeds. Minimum friction, highest consistency.
When: Teams with less senior developers, or where description quality is a persistent problem.
Developer writes description as usual. AI checks alignment with diff, template adherence, and completeness. AI warns only; developer authorship preserved.
When: Teams where every submit deserves author-written prose.
If developer wrote substantial description, AI validates. If developer wrote minimal placeholder, AI proposes a full description. Respects developer autonomy while catching lazy submissions.
When: Most studios pick this one after seeing the trade-offs.
Seat-based or API-based
Both options produce equivalent quality of analysis. The choice is about operational preference, not capability. Most studios choose Option A initially and migrate to Option B if compliance or observability needs grow.
The pre-submit hook invokes the developer’s AI coding assistant locally. The developer’s seat handles the AI call. No additional cost per submit. Simpler to configure. Uses whatever seat quota the developer has.
Best for: Studios with generous seat allocations, teams preferring simplicity, straightforward workflows.
The pre-submit hook makes a direct API call using the studio’s API key. Structured output guaranteed by schema. Independent of seat state. Better observability for compliance auditing.
Best for: Studios with strict compliance requirements, high submit volumes, or preference for centralized cost tracking.
What it is not
Not another code quality review
Layer 1 handles quality at write time; Layer 4 handles deep analysis post-submit. Layer 3 is about submit-readiness, not code correctness.
Not a gate that developers battle
Well-configured, Layer 3 saves developers time by handling metadata construction automatically. If developers experience it as bureaucratic friction, configuration is wrong.
Not autonomous
Even auto-generated descriptions require developer confirmation before the submit proceeds. AI never submits code without human decision.
Not required for every changelist
Trivial changes (typo fixes, comment updates) can be exempted from full Layer 3 processing. Configurable during Setup.
The shared brain
Everyone can read it; only tech leads can change it, and only through review. That is what keeps AI consistent instead of inventing its own conventions.
What it contains
Conventions
Coding standards, naming rules, and formatting requirements per language and subsystem.
Architecture
Module boundaries, ownership, dependencies, allowed and forbidden interactions.
Decisions
Architecture decision records with rationale for significant choices.
Examples
Canonical implementations of common patterns, curated and versioned.
Anti-patterns
Explicit "never do this" catalog derived from historical bugs and reviews.
Workflows
Standard procedures for common tasks: new feature, bug fix, refactor.
Platform notes
Console SDK guidance, certification requirements, mobile constraints.
Skills
Task-specific patterns your AI assistant uses to accomplish structured workflows.
How it is consulted
How it is protected
How it is updated
Tech lead identifies need for update, creates PR with proposed change, CI validation runs, required reviewers approve, change merges to main, tagged release triggers deployment.
Weekly worker identifies patterns worth capturing, generates a PR with proposed updates including rationale and examples. Tech lead reviews with the same rigor as human-authored PRs.
Critical issue in content (e.g. outdated security guidance). Designated senior tech lead fast-tracks with single approval. Post-hoc review required within 48 hours. Audit log captures rationale.
Every path passes through the same automated + human check.
Immutable version. Semantic versioning applies.
Sessions and workers pick up the new version on next query.
Versioning & rollback
Telemetry
Skills & integrations
Two things make the AI feel like it belongs to your studio rather than a generic assistant: the tools it can safely reach, and the skills it knows how to run.
Connected via MCP
We integrate with the tools you already run, with audit logs and path controls on every operation. No rip-and-replace.
Illustrative, not exhaustive. If a tool has an API or an MCP server, it can be connected.
Studio-adapted skills
Skills are named workflows the AI knows how to run, each following your conventions. We ship a ready-made library and build custom ones for your project. A representative set:
Plus any custom skill your workflows call for. New skills are versioned in the knowledge layer and reviewed like any other change.
What lives where
The cross-boundary arrows show exactly what leaves your network, and it is only what the AI needs to answer a request.
Studio infrastructure
Knowledge Repository
Git, private
MCP Context Server
Small VM · 2 vCPU / 4GB
Developer Workstation
Any MCP-compatible client
Automation Worker
Small VM or serverless
Studio Systems
Perforce, Swarm, Jira, Slack, CI
Vendor infrastructure
Interactive AI Seats
Vendor-hosted
Programmatic AI API
Vendor-hosted · key-based
Inside your infrastructure
Inside vendor infrastructure
What we add
Two small VMs. That is the entire additional infrastructure footprint. Everything else uses infrastructure the studio already runs.
Who pays what
Most vendors skip this. Here is exactly what money flows where, with real ranges for a 50-developer studio.
Fixed monthly (predictable)
AI seats (interactive use)
Studio → vendor
~€30-40 / developer / month
Paid directly, no markup. Number of seats matches the developers who need interactive AI assistance.
Infrastructure hosting
Studio → cloud or self
~€30-100 / month total
Two small VMs. Depends on your chosen hosting.
Optimization retainer (optional)
Studio → us
~€2,000-15,000 / month
Scales with studio size. Ongoing knowledge evolution, integration maintenance, system optimization.
Variable monthly (paid directly to your AI vendor)
Layer 3 API (if API-based)
€50-150 / month
For a 50-developer studio at ~2,000 submits / month. Zero if seat-based.
Layer 4 (post-submit review)
€300-800 / month
For a 50-developer studio. Scales roughly linearly with submit volume.
Layer 5 (continuous evolution)
€30-100 / month
Weekly / monthly batch jobs.
Total API charges typically €400-1,000 / month for a 50-developer studio; €1,500-4,000 for a 200-developer studio.
One-time (paid to us)
AI Readiness Audit
~€4,000-35,000
Fixed-fee, one-time. Written report you keep regardless of next steps.
Setup & Integration
~€10,000-130,000
Fixed-fee, one-time. Infrastructure deployment, integration, knowledge construction, skill library, training.
What we do not charge for
Deployment & operations
During Setup, we deploy
During Support, we maintain
You operate
The studio owns and operates the two VMs after handover (standard sysadmin work). We maintain the knowledge content, skill library, and configuration through the retainer. If the retainer ends, everything continues to work, studio owns all infrastructure, all code, all configuration. Zero vendor lock-in on us.
What we do not operate
We do not host anything on our infrastructure. Everything lives in the studio’s environment. This is deliberate: better for IP protection, better for compliance (your security team can audit exactly what runs where), better for your long-term autonomy.
Privacy tiers
From vendor-hosted to fully self-hosted behind your firewall. Each with concrete vendor options.
Tier 1
Vendor-hosted, no training
Standard commercial terms with a hosted AI provider. No training on your data (default in commercial plans). Short operational retention for safety and debugging.
Indie and small studios without strict IP requirements.
Claude for Work · ChatGPT Enterprise · Gemini for Google Workspace
Tier 2
Zero data retention
API access with a contractual addendum removing retention beyond immediate processing. Requires separate negotiation with your chosen vendor. Prompts and responses processed and immediately discarded.
Studios with moderate IP sensitivity or publisher requirements.
Anthropic API + ZDR · OpenAI API + ZDR · Google Vertex with logs disabled
Tier 3
Runs inside your account
The model runs inside your cloud provider account. Your code never touches the vendor’s infrastructure directly. Data residency guaranteed by your cloud provider. Zero data retention automatic.
Studios with strict IP requirements, regulatory compliance, or existing cloud commitments.
AWS Bedrock · Google Vertex AI · Azure OpenAI
Tier 4
Nothing leaves the perimeter
Open-weight models running entirely on your infrastructure, coordinated by MCP tunnels. Tool execution and data access stay inside your perimeter.
AAA studios with console SDKs, strict NDAs, or classified project requirements.
Llama 3 / 4 · Mistral · DeepSeek · Qwen, behind your firewall
Important distinction
Default everywhere
Default in every commercial AI plan across major vendors. You do not need special contracts for this. Consumer accounts (personal Claude, ChatGPT, Gemini) typically require explicit opt-out; commercial and enterprise accounts have it by default.
Requires an addendum
Requires a Zero Data Retention addendum or a higher-tier deployment (in-cloud or self-hosted). This is a separate contractual layer. Commercial APIs typically retain data for 30 days operationally; ZDR eliminates that retention.
Honest limits
In plain terms
Developers work as they always do, with a smarter AI assistant that knows your studio’s rules.
A small server sits inside your network holding your studio’s collective knowledge and serving it up when needed.
Another small server watches for events, submits, build failures, weekly schedules, and does the deeper analysis that would otherwise consume senior engineering time.
The AI vendor hosts the model. You keep the code, the knowledge, and the infrastructure.
Two subscriptions. Two small servers. Five layers that know when to run and when to stay quiet.
Your stack, your compliance constraints, your integration edge case. 30 minutes, free, engineer to engineer.
Analysis ready for review. Convention and formatting already handled upstream, here is what needs a human eye:
The tech lead spends five minutes on the architecture, not forty on the basics.