How the work runs.

One change, from ticket to product, and what lets us trust it along the way.

A loop, not a project.

  1. 01
    LearnWe see how people actually use the product and where they struggle.
  2. 02
    DecideWe choose what matters, what to change and what success looks like.
  3. 03
    Build & verifyAgents implement, test and improve their own work.
  4. 04
    MeasureReal usage tells us what worked and what to improve next.
↻ Continuous learning and improvement

Where the work starts.

Some work starts with a decision we make. Other work starts automatically, triggered by what's happening in the product or codebase.

TICKET

We define the problem, what success looks like and any constraints. An agent takes it from there.

OR TRIGGERED AUTOMATICALLY
Error in production
An agent reproduces the issue, finds the cause and prepares a tested fix.
Feedback from a user
An agent groups it with similar reports, finds the root cause and suggests what to fix first.
Signal in the data
An agent investigates the findings. We decide what to act on.
Scheduled checks
Agents look for security issues, performance problems and maintenance needs.

Two principles behind everything.

1 A codebase designed for agents. Fewer mistakes, through architecture, structure, conventions and automatic constraints. 2 Give agents the tools to verify. Agents find, understand and fix the mistakes that still happen, without us doing the checking for them.

A codebase designed for agents.

We don't rely on agents remembering every instruction. We design the architecture, enforce conventions and provide the context they need to work independently.

  1. 01Strong types and lint rulesTypeScript and lint rules catch mistakes and enforce conventions automatically.
  2. 02Predictable structureEvery feature has its place. Agents follow established patterns instead of inventing new ones.
  3. 03Shared building blocksComponents, authentication and data access are reused, not reinvented.
  4. 04Context at handAgents can access documentation, decisions, logs and previous work instead of guessing.
  5. 05Security by designPermissions, secrets and customer data follow enforced patterns, with automated checks for violations.

Give agents the tools to verify.

Agents can't reliably build what they can't run, see or debug. We give them the same tools and feedback a developer uses, so they can find and fix problems themselves. They check that it works. Whether it's good enough is our call.

  1. 01
    Build & checkAgents write the code, run TypeScript checks, linting and automated tests.
  2. 02
    RunAgents start the actual application in their own environment.
  3. 03
    Use & inspectBrowser automation lets agents interact with the product, inspect the console, network requests and logs.
  4. 04
    Fix & repeatAgents debug what fails, make corrections and repeat the checks until the result is verified.
↻ UNTIL VERIFIED

Many tracks, one direction.

Each task runs in its own track, so many things get built at once. We move between them like a director between sets.

  • Shorter sign-up formPR OPEN
  • First report draft, automaticallyBUILDING
  • Crash on empty customer listTESTING
  • Invoices to the new schemaBUILDING
  • Shortcut: "repeat last trip"WAITING ON US

The last row is the point: the agent is ready, and the decision is ours.

Autonomy follows risk.

Every change passes automated checks and independent agent review. How much autonomy an agent gets depends on the risk.

From prototype to product.

A prototype takes an evening to build, so we make many and keep few. A product only moves on when the people using it give us a reason to.

  1. PROTOTYPE
    Test the ideaQuick and rough. Most stop here.
  2. IN DEVELOPMENT
    Used in real workSomeone relies on it. Now we build it properly.
  3. BETA
    More usersWe learn what's missing and what's in the way.
  4. LIVE
    Earned its placeWe keep improving it for as long as it's used.
WHAT IT TAKES TO MOVE ON
  1. 01Do people come back?Trying it once isn't enough. It has to become part of how they work.
  2. 02Is it clearly better?Better than what they use today, by enough that switching is worth it.
  3. 03Does it pay for itself?People pay enough for it to cover running and improving it.

What doesn't get there, we shut down. What we learned goes into the next one.

Improve the system, not just the code.

When agents make mistakes, we don't just fix the code. We improve the rules, tools and environment so the next agent doesn't repeat them.

Every improvement makes the entire system more reliable.

The philosophy behind it → What it turns into →