AI-driven development,
under strict engineering control
We build with Claude Code, Codex and open-source models — and every line they write passes through the same review gate, test suite and CI as human code. AI moves us faster. It never decides what ships.
- Human review gate
- EU-based
- GDPR & AI Act-native
- No proprietary runtime
Speed where it’s safe. Judgement where it matters.
AI is genuinely good at a narrow band of software work, and genuinely unreliable outside it. We use it hard inside that band and not at all outside it — that split is the whole method.
What AI accelerates
Mechanical implementation
Boilerplate, adapters, migrations, test scaffolding, repetitive refactors across many files — work that is well-specified and tedious rather than hard.
Reading unfamiliar code
Tracing how an existing system actually behaves before we change it — the part of legacy work that normally burns days of discovery.
Breadth of options
Drafting several viable approaches quickly, so the design conversation starts from real alternatives instead of the first idea that fit.
Documentation & tests
The work that gets cut first under deadline pressure now gets written — which is where a lot of the durable quality gain actually comes from.
What stays human
Architecture
What to build, how it should be structured, and which trade-offs your business can live with. A model has no stake in your five-year cost curve.
The merge decision
No AI-authored line reaches your repository without a named engineer reading it and approving it. There is no auto-merge path. Ever.
Security & data boundaries
What a model is allowed to see, where it runs, and what leaves your environment is decided by us in advance — never by the tool at runtime.
Accountability
When something breaks at 3am, a person is responsible and reachable. “The AI wrote it” has never been an acceptable answer here.
The AI toolchain we actually run
No mystery stack. These are the tools in our day-to-day engineering, each paired with the control that governs it.
Claude Code
Agentic coding inside our repositories — implementing scoped tickets, refactoring across many files, and tracing behaviour through unfamiliar systems.
Controlled by
Runs on a feature branch, never directly on main. Output arrives as a normal pull request and is reviewed by the engineer who owns that service.
Codex
Scoped generation and mechanical refactors, plus a useful second opinion when two approaches look equally reasonable.
Controlled by
Given the code it needs and nothing else — no production credentials, no customer data. Its output clears the same type checks, tests and CI as any human commit.
Open-source models, self-hosted
Used when your data cannot leave your environment, or when a workload should not depend on a third-party API at all.
Controlled by
Runs on infrastructure we or you control, inside your data boundary. Nothing is sent to an external inference provider.
All three tools converge on the same control gate — feature branch, scoped context, full CI, human review — and leave it through a single output: a reviewed commit in your repository.
Three tools in
Claude Code
Runs in our shell, inside your repository.
Codex
A vendor-run hosted engine we send scoped tasks to.
Open-source models, self-hosted
Runs on a machine you or we own, inside your data boundary.
One gate
The same four controls, whichever tool wrote the draft
- Feature branchNever committed straight to main.
- Scoped contextThe code the task needs. No production secrets, no customer data.
- Full CIType checks, linting and the same test suite as any human commit.
- Human reviewA named engineer reads it and approves the merge.
One way out
Reviewed commit in your repo
Same history, same authorship, same approval trail as everything else we ship.
The tools differ in what they are good at. What they do not differ in is how their output reaches main.
Tools change; the controls don’t. When a better model ships, it enters through the same gate as the last one — branch, review, tests, CI.
The harness around every AI-assisted change
Using AI responsibly is not a policy document, it’s a set of mechanisms that make the unsafe path impossible. These are ours.
- 01
Scoped on a branch
Acceptance criteria agreed in writing, then work starts on a branch. Nothing writes to main directly.
- 02Provisional
AI drafts
Claude Code, Codex or a self-hosted model writes a first pass. A proposal, not a change.
- 03
Automated gates
Type check, lint, unit and integration tests — the same CI as human-written code.
- 04Required
Human review gate
A named engineer reads the diff and approves, requests changes, or rejects. No approval, no merge.
- 05
Merge to main
The approved change lands on main, author and reviewer recorded in git.
- 06
Deployed & monitored
Released through the same path as any other change, with logging, metrics and alerting on it.
Every stage above runs inside our own tooling. These are not habits a developer can skip when a deadline is tight — the harness is what makes them mandatory, and what makes the sequence auditable after the fact.
- Dashed: draft output, provisional until a person approves it.
- Solid: reviewed, approved, and on its way to production.
- There is no route around the review gate — no path leads from a draft to main without it.
Inside the boundary
What the model receives
Scoped to the task in front of it, and nothing else.
- The repository or module the ticket touches
- The ticket description and acceptance criteria
- Tests and type definitions
- Public documentation for the libraries in use
Where the model runs
EU infrastructure by default
Hosted models run on business tiers configured so your code is not retained for training. Data residency is chosen deliberately per engagement, not assumed.
Self-hosted open-source models
When data cannot leave at all, the model runs inside your own environment. Nothing is sent to an external inference provider.
Outside the boundary
What never leaves
Never loaded into a model’s context, on any provider.
- Production secrets and credentials
- Customer records and personal data
- Live production databases
- Payment data
What this means for you
The point of the controls isn’t process for its own sake. It’s what you’re left holding at the end of the engagement.
Clear terms, and the keys to run it
We work in your repository and your cloud accounts wherever possible, so the keys and the infrastructure stay in your hands. Ownership and licensing of what we build are agreed explicitly in the contract, before the first sprint — not discovered at handover.
EU-based, GDPR and AI Act-native
Built in the EU with data protection and the EU AI Act treated as design constraints from the first sprint, not a compliance scramble before launch.
A mainstream, open stack
React, Next.js, TypeScript, Node, Python, PostgreSQL. Any competent team can pick this up — including yours, if you decide to take it in-house.
AI in the product, not just the process
We run our own AI products in production, so the assistants, scrapers and predictive systems we build for you come with real operational experience behind them.
Questions we get asked
The honest answers, including where the limits are.
Do you use AI to write our code?
Yes, for parts of it, and we’d rather tell you than have you assume otherwise. AI handles well-specified mechanical work — boilerplate, adapters, migrations, test scaffolding, wide refactors. Architecture, security decisions and the choice of what ships stay with our engineers. Every AI-assisted change is reviewed and approved by a named person before it merges.
Which AI tools do you use?
Claude Code and Codex for agentic coding inside our repositories, plus self-hosted open-source models where data residency or independence from a third-party API matters. All three sit behind the same controls: feature branches, pull-request review, full CI, and no access to production secrets or customer data.
Is AI-generated code safe to run in production?
Only under a harness — which is why we built one. Unreviewed model output is not safe, and anyone claiming otherwise is selling something. In our process no AI-written line reaches your repository without an engineer reading it, and it passes the same type checks, tests and CI as human code. The safety comes from the gate, not from the model.
Will our source code or data be used to train AI models?
No. We use business and API tiers configured so your code isn’t retained for model training, and we scope what models can see to the task at hand — production secrets and customer records stay outside that boundary. Where a workload can’t use a hosted model at all, we run open-source models inside your own environment so nothing leaves it.
Does using AI make the project cheaper or faster?
Faster on the mechanical half of the work, which usually shows up as shorter iterations and more of the project’s budget going to design, testing and hardening rather than typing. We won’t quote you a percentage — it depends heavily on the codebase and how well-specified the work is, and anyone who gives you a firm number hasn’t measured it either.
Can you build without any cloud AI providers?
Yes. For data that can’t leave your environment, we run open-source models on infrastructure you or we control, with no third-party inference involved. It changes the cost and capability envelope, so we’ll be straight with you about the trade-offs before you commit to it.
Who owns what you deliver?
Ownership and licensing are a contract question, and we settle them in writing before the work starts rather than at handover. What does not depend on the contract is portability: we work in your repository and your cloud accounts wherever possible, on a mainstream open stack — React, Next.js, TypeScript, Node, Python, PostgreSQL — with the full git history intact. There is no proprietary runtime and no extraction project. Whatever we agree on ownership, you are never technically trapped.
How does this fit the EU AI Act and GDPR?
We’re an EU company building for European businesses, so both are design constraints rather than afterthoughts: lawful basis and data minimisation are decided during discovery, data residency is chosen deliberately, and where a system makes decisions about people we build in traceability and human oversight from the start. For regulated deployments we work alongside your DPO or counsel — we build to the requirement, we don’t certify it.
Bring us something hard
Tell us the problem and the constraints you’re actually under. You’ll get a structured pre-analysis back — what we’d build, how we’d control it, and where the risks are. Not a sales deck.