Quality

Every feature described. Every one checked.

Software rarely breaks with a bang. It breaks quietly: a button moves, an email stops arriving. We write down what your software has to do, and check it on every change.

funnel.erstgespraech.buchenExample
Book an intro call with a time slot
Who
Visitor without an account
Priority
High, main path to enquiries

Must hold

  • The topic is chosen before the time.
  • Only free slots from the calendar appear.
  • Nothing is booked without consent.
  • A calendar invitation follows the booking.
Checked byBrowser testAI agent

The behaviour catalogue

First write down what must hold. Then check it.

  1. Describe

    Every behaviour of your software gets a short entry in plain language: who uses it, what must hold, how important it is.

  2. Link

    Every test points to the behaviour it checks. If an important behaviour has no test, you see it straight away.

  3. Check

    On every change the tests run automatically. Where no test is enough, an AI agent checks in a real browser, and a person checks anything that changes data.

On every change

Eight stations before anything goes live.

The same route for every change, whether it comes from an AI agent or a person. If one station fails, nothing moves on.

  1. Change

    From an AI agent or a person, always as a traceable proposal.

  2. Style and types

    Biome and TypeScript catch typos and wrong data.

  3. Logic

    Vitest checks calculations and rules in seconds.

  4. Catalogue check

    No behaviour disappears from the catalogue unnoticed.

  5. Real browser

    Playwright clicks through the important paths, like a customer.

  6. Security

    Code and dependencies are checked for known vulnerabilities.

  7. Approval

    A person looks at the result and approves it.

  8. Live

    With monitoring and a way back, in case something does go wrong.

Every night: full test runs, plus load time and quality with Lighthouse.

Every week: findability, with a local AI model.

Dynamic, not rigid

Tests that grow with the software.

Classic tests check what someone wrote down months ago. The catalogue describes what should hold and leaves open how it is checked: by a test, an AI agent or a person.

  • Waves, not spot checks

    During a rebuild every behaviour is confirmed again. The wave shows at any moment what is checked, open or blocked.

    checkedopenblocked

  • AI agents fill the gaps

    Where no test exists yet, an agent checks the behaviour in a real browser. Only a person checks what changes data.

  • Step budgets

    Every important path has a maximum number of steps. If a rebuild makes it longer, the check fails, even when everything else is green.

  • Measuring findability

    A local AI model gets nothing but a one-sentence goal and finds the way itself. How often it has to guess shows where the interface is unclear.

For engineers

What we check with.

  • PlaywrightTests in a real browser
  • VitestFast logic tests
  • TypeScriptTypes instead of surprises
  • BiomeStyle and error checks
  • GitHub ActionsPipelines on our own runners
  • RenovateDependencies kept current
  • MCPAgents read the catalogue
  • mechanicsThe catalogue, open source
  • flow-metricsBudgets and findability

mechanics/funnel/erstgespraech-buchen.md

---
title: Book an intro call with a time slot
kind: user-facing
priority: p0
claims:
  route: ["/buchen"]
verify: e2e
---

e2e/buchen.spec.ts

// @mechanic hansenexus.funnel.erstgespraech-buchen

The catalogue lives as Markdown in the repository. Tests point to their behaviour in a comment, the check runs as a required step in the pipeline, and agents query the catalogue over MCP.

mechanics on GitHub

Two ways

Included, or booked on its own.

In every package

Part of everything we build and run.

Every application we build or run for you gets its catalogue, its tests and its pipeline.

  • Catalogue and tests grow with every change
  • A check before every release
  • It belongs to you, even if you leave

As a fixed-price project

For software that is already running.

Even if we did not build it: we describe what your software has to do, build tests and a pipeline, and hand everything over to your team.

  • Assessment and catalogue
  • Tests for the most important paths
  • A pipeline with a check before every update
  • Handover with training, fixed price after the assessment

How well is your software safeguarded?

We look at it together in the intro call. 30 minutes, free of charge, by video or phone.