How we work

AI writes the code. A senior decides what ships. That split is the whole method.

Alex, Henry and specialist agents routing work through the studio

The workflow

Six steps. Every feature, every bug fix, every change goes through all of them.

How we build with AI: plan first, review every diff, write the mistakes down. Senior judgment on top of AI speed.

Issue tracking

Every task lives in Linear or GitHub Issues, with specs, acceptance criteria and context. No ticket, no work.

We work like a large team because we are one. Structure is what makes speed safe.

Planning

AI proposes an approach. A human reviews it, asks questions and refines it. We iterate until we agree.

Nobody writes code before the plan holds. Bad plans turn into expensive bugs.

Implementation

AI writes the code, the tests and the docs. A human reads every diff as it lands.

Feed it one file and one problem at a time. Dumping a whole codebase into context makes the output worse.

Testing

Unit, integration and end-to-end tests run on every build and every deploy.

No green, no ship. Tests are how we check what the AI says it did.

Review and merge

AI opens the pull request. A human reviews it and merges it. CI has to pass first.

Pushing straight to main is forbidden here. Every change earns its way in.

Documentation

Code changes trigger doc updates. Architecture decisions get recorded.

Mistakes go in writing too, so the same one costs us once. Chat disappears; docs survive.

Tech stack

AI Models

Claude Fable · Claude Opus · GPT · GLM · Qwen Coder (local) · Qwen Max (local) · Gemma (local)

Languages

TypeScript · Python · Rust · Go · Swift · Kotlin · SQL

Frontend

React · Next.js · SvelteKit · Astro · Tailwind CSS · Framer Motion

Mobile

SwiftUI · React Native · Flutter · Expo

Backend

Node.js · FastAPI · NestJS · Hono · Express · Encore · Prisma · Drizzle

Henry and specialist agents assembling the technical stack

Images and film

The scenes on this site are generated, not stock. Same rule as the code: the right model for the job and a human who decides what ships.

Most of it runs on our own hardware. Open models, a local GPU and a command line the agents can drive. Nothing leaves the building unless a hosted model does the job better.

Generation is the cheap part. The work is the brief, the references and the review. An agent pulls frames and checks faces, hands and text before a person looks at it.

Local first

Stills, clips and sound are rendered on our own machine. It costs nothing per image, so we can afford to throw most of them away.

Model per task

One model for photographic stills, another for people in motion, a third for editing from references. We swap them when something better ships, which is often.

Real devices, real UI

App screens are never generated. Mockups put the actual interface on accurate device models, so what you see is what was built.

Proactive monitoring

Our agents watch your systems around the clock and fix problems before your users notice.

Most teams find bugs when users report them. We find them at 3 AM.

The agents read your logs, error trackers and metrics. When something looks wrong you get a report with the root cause and a proposed fix, not just an alert.

We run this on our own ventures every night. That is where Vigil came from, now a managed service at vigil.kerber.ai.

Continuous log analysis

Agents watch Sentry, Datadog, CloudWatch and your own logs. Pattern matching catches what static alerts miss, like a slow memory leak or a creeping error rate.

Overnight fixes

A critical bug found at 2 AM has a pull request by 6. Smaller ones get written up and prioritised.

Trend detection

Usage patterns, infrastructure costs, API deprecations. You hear about them before they turn into incidents.

But who takes over when seniors move on?

The right question. Here is our answer.

What happens when the senior who knows what good looks like walks out the door?

Companies do not need that person full time. They need the judgment: one or two hours a week, not forty hours of babysitting.

The reviews leave something behind as well. Documented patterns, architecture decision records and test suites that spell out what good looks like on this particular codebase. Senior knowledge has to outlive the senior.

Expertise on demand

Senior oversight without a senior salary. One expert can guide several projects at once.

Knowledge that persists

Every review becomes documentation. Every decision gets recorded. When we leave, the quality systems stay.

Faster learning loops

Juniors working with AI get feedback in seconds. The 2027 junior will have seen more patterns than a 2017 senior.

Want this for your team

We help companies set up AI-augmented workflows that hold up in production. Most of that work is the system around the tools.

Book a consultation