Frontends that ship on schedule and leak nothing

We are a spec-driven agency: every rule your product must follow is written down and agreed before any code. Senior engineers and supervised coding agents build to that spec, and every change ships with its security and privacy checks.

Spec before code
100%
Changes shipped without checks
0
Third-party trackers
0
Accessibility
WCAG 2.2

Where frontend projects fail. Five problems we are hired to fix.

The problemWhat we do
Requirements that live in chat threadsEvery rule becomes an acceptance criterion in one versioned spec that scope, tests and review read from.
Velocity that drops as the code growsClear module boundaries and a recorded decision for each, so teams ship in parallel without breaking each other.
AI-written code nobody can verifyAgents build only from tasks in the spec; every change passes its criteria and a senior review before merge.
Scripts leaking user dataAn inventory of every third-party script and storage key, with nothing loaded before consent.
Security found after launchA threat model in the spec, then headers, dependency audits and secret scanning on every pull request.

Frontend services, spec first. What you get from each.

  • Spec Sprints

    A clear scope and a quote before you commit to a build.

    One to two weeks to a versioned spec pack: feature specs, a threat model, a data map and a delivery plan.

  • Frontend architecture

    A codebase that stays quick to change as the product grows.

    Module boundaries, the right rendering approach for each page, and design tokens, with every decision recorded.

  • Agent-assisted delivery

    More shipped each week, with a senior engineer reviewing every change.

    Coding agents build from the spec’s tasks in parallel; a senior engineer reviews every change before merge.

  • Quality gates in CI

    Every rule in the spec is checked automatically before release.

    Acceptance criteria as Playwright and Vitest suites, with accessibility and visual checks on every pull request.

  • Security by standard

    Fewer surprises in a security review, because the checks run on every change.

    A threat model, a strict Content Security Policy (only approved scripts can run), safe sessions, and dependency and secret scanning.

  • Privacy by standard

    Nothing about your users leaks to third parties.

    No trackers, nothing stored before consent, and every field in a form mapped to a written purpose.

  • Performance and Core Web Vitals

    Pages that load fast on real phones, and stay fast.

    Real-user data first, then fixes for load speed, responsiveness and layout shifts (Core Web Vitals), held by budgets that fail the build.

  • Migrations and modernisation

    Off a legacy stack without a risky all-at-once launch.

    Each change written into the spec as added, modified or removed, then moved over one page at a time.

The spec comes first

Before any code, we write down every rule your product has to follow, in plain statements a test can check. Our engineers, the coding agents, the automated checks and your own security review all work from that one document, so nothing is lost between a meeting and a release.

session-security.spec.mdv2.1 · security
Feature: Session ends on idle  Given a signed-in user on a shared device  And no activity for 15 minutes  When the user returns to the tab  Then the session is ended and the screen cleared  And no personal data remains in storage

How to read a spec

The behaviour, named in plain words.
One acceptance criterion: the situation, what the user does, and the result the release has to prove.
Each criterion is numbered, becomes a task, and runs as a test on every change.

From spec to release, step by step. For every feature.

See each step in detail
  1. 01

    Agree the spec's ground rules

    Architecture, accessibility, performance budget, and the security and privacy baseline, agreed once.

  2. 02

    Write each feature spec

    Each feature as stories and acceptance criteria, with its threat model and the data it collects.

    Never skipped
  3. 03

    Split the plan into tasks

    Architecture, dependencies and tests, split into tasks that each meet a criterion.

  4. 04

    Build and verify each feature

    Engineers and supervised agents build to the tasks; each release ships a criterion-by-criterion report.

  5. 05

    Change the spec first

    A new requirement, risk or review finding becomes a spec change first, then code.

Privacy and security, as the standard.

Written into every spec before the first feature, and checked on every change, so a rule cannot quietly drop out.

On every change

  • Security checks in CI

    Headers, dependencies, secrets and permissions are checked automatically on every change; a serious finding stops the release.

  • Agents under supervision

    Agents work only on tasks from the spec, in a sandbox without production secrets, and a senior engineer approves every merge.

  • Data you never collect

    No trackers, no fingerprinting and nothing stored before consent; every field in a form has a written purpose.

The baseline every spec starts with

  • Strict Content Security PolicyOnly scripts we approved can run.
  • No third-party requests by defaultNothing calls out to another company.
  • Nothing stored before consentNo cookies or storage until the user agrees.
  • No secrets in the clientKeys stay on the server, never in the browser.
  • Dependency and secret scanningEvery change is checked for known flaws and leaked keys.
  • Data minimised per fieldEach form field has a written reason to exist.

Example engagements. Illustrative, not client results. Real work stays under NDA.

Case file, redacted for publication
1. Context
The client, name withheld, ran several products on copies of one legacy frontend.
Screens removed. Each copy had its own fixes, build and release calendar.
We wrote the spec pack first, then moved every route to one architecture.
Every switch was gated by tests that compared the old and new routes.

Why teams trust a discreet agency. Six things you get from us.

  • Signs an NDA before any spec

    We sign before the first technical conversation, and never name a client or show their screens.

  • Ships frontends with no trackers

    Nothing loads before consent, and every script and storage key is listed in the spec.

  • Hands you the spec pack

    The spec pack is yours: a contract, a test plan and an audit trail in one.

  • Puts senior engineering on the code

    The people on the first conversation are the people who write and review the code.

  • Keeps contact on private channels

    Signal, Telegram or Session on company accounts, and invoices payable in USDC, USDT or BTC.

  • Transfers code and specs on payment

    Code, specs and design files pass to you on payment, documented for the team that keeps them.

Questions before a first conversation. Ask us anything else in private.

Is the first conversation free?

Yes, and it commits you to nothing. We sign an NDA before you share any details.

Will you sign an NDA?

Yes, before any details are shared. We can sign yours or send ours, and it covers everyone who works on your project.

What does spec-driven development change for us?

Requirements, tests and review read from one versioned spec, so the scope is clear, engineers and agents build the same thing, and every change shows what it proves.

How do you keep agent-written code safe?

Agents work only on tasks from the spec, in a sandbox without production secrets, and nothing merges without passing checks and a senior review.

How do you price the work?

A Spec Sprint is fixed scope. Builds are quoted against the spec, retainers per month. We share prices in private.

Send us your question

Four ways to work with us. We quote after the spec.

Spec Sprint

Best for
A new product, feature set or rebuild
How it works
One to two weeks to a versioned spec pack
Commitment
Fixed scope; credited against a build

Build

Best for
A product with an agreed spec and a date
How it works
Milestones mapped to spec sections
Commitment
Changes written into the spec and priced first

Embedded retainer

Best for
Teams that need senior architecture and velocity
How it works
A senior lead plus supervised agents
Commitment
Monthly, with spec changes tracked

Audit

Best for
A live frontend before a launch or a review
How it works
Architecture, tests, speed, accessibility, privacy and security checked
Commitment
Findings written as spec changes, ready to build

Not sure which fits? Ask us on a private channel

Start a Spec Sprint. Contact us on a private channel.

Tell us the product, the scope and the date. We reply on the same channel and send an NDA before any details.

What happens next

  1. You message us on Signal, Telegram or Session.
  2. We sign an NDA and agree the scope of a Spec Sprint.
  3. One to two weeks later you hold a versioned spec pack.
Mutual NDA, draft 1
2. Confidential information
Each party keeps the other’s information confidential for five years after the last disclosure.
Everyone who works on the project is bound by these terms, engineers and agents alike.
Nothing is shared with third parties, and no client name appears in our work.
Either party may ask for every copy to be returned or destroyed.

Our company accounts

Each link opens the messenger’s own app, which needs to be installed.

  • We reply the same working day, in EU and Americas hours.
  • The first conversation is free and commits you to nothing.
  • We sign an NDA before you share any details.

Payment

  • Bank wire (USD, EUR)
  • USDC
  • USDT
  • BTC
Start a Spec Sprint