How we work
A software factory with the lights on.
Some teams now let AI write and ship software with nobody looking at the code. They call it a dark factory. We work the other way: agents do the building, every check is on the record, and a person signs what ships.
Checking is not the last step. It is every step.
When software is written faster than it can be checked, the gap between what exists and what can be trusted grows every day. So we do not check at the end. The checks are built into the work, from the first decision to the last release.
Three things every change has to prove.
Around our agents is a set of tools and checks. No change reaches you until it has passed all of them. They look for three things:
- It works. It does what you asked for, checked against the acceptance criteria and not against a demo.
- It lasts. The code stays clear enough for a team to read and maintain years from now.
- It can change. The parts stay separate, so one can be replaced without rewriting the rest.
That is what “built to last, easy to evolve” means in practice.
Humans set direction. Agents multiply execution. Verification earns trust.
The lead engineer Decides what is being built and why, sets the architecture and the limits, defines what “done” means, and signs the release.
Agents, each with one job
- Context Maps the existing code, the business rules and the constraints before anything changes.
- Architecture Proposes structures and tests them before they become expensive code.
- Build Implements bounded tasks in parallel, inside explicit rules.
- Verification Challenges the result: function, business logic, security, edge cases. Never the agent that built it.
- Maintenance Finds and removes technical debt and keeps the documentation in step with the system.
Direct. Build. Challenge. Sign. Stay.
- Direct
Before any code is written, the lead engineer writes down the goal, the limits and the acceptance criteria. Agents start from that, not from a guess.
- Build
Specialized agents research, design and implement in parallel, inside those limits.
- Challenge
Different agents inspect the assumptions and the logic. Automated tests, static analysis and security checks verify what must be repeatable. Whatever fails goes back for repair, and every repair goes through every check again.
- Sign
The lead engineer reviews the evidence and signs the release. Nothing ships because a model said it was done.
- Stay
We do not leave at release. We keep checking the system while it runs and are there when it needs to change.
Clean code is no longer only for people.
Agents work better in a system they can understand, and so do the people who come after them. Clear boundaries, focused modules and current documentation make every future change faster and safer. For us clean code is not a matter of taste. It is what keeps a system easy to change.
You receive the evidence, not only the software.
With every release you get:
- the test results;
- the list of checks: what passed, what failed, what was sent back and fixed;
- who approved the release, and when;
- documentation that matches the system as delivered.
What we do not promise.
Nobody can honestly promise software without defects, and we do not. We promise that risks are looked for, written down and kept under control, and that you are told about the ones we cannot remove.
We do not leave at release.
Software keeps changing after it goes live, and so does the business around it. We keep checking the system while it runs, and we are there when it needs to change. There is no long-term contract to sign first: how long we stay is agreed with you as we go.
No lock-in.
The code, the documentation and the evidence are yours. Change the system later with us, with your own team, or with anyone you choose. Nothing lives in one head: every decision, check and approval is on the record.
Bring us the system you cannot afford to get wrong.
Your first conversation is with our lead engineer.