Why a factory

AI coding tools make code cheap. They do not make it correct. Most teams that adopt them find the same three problems:

  • The tool grades its own homework. Code and tests written by the same assistant agree with each other, including when both are wrong.
  • Review becomes the bottleneck. More code arrives faster than anyone can read it.
  • The knowledge lives in a chat window. Decisions, context and reasons disappear when the session ends.
  • The Software Factory is our answer: a production line where agents do the volume, independent checks decide what is correct, and people make the calls that matter.

    How it works

    Every change, from a one-line fix to a new module, runs the same line.

    StationWhat happens
    1. RequirementYour request becomes a ticket and a document. Nothing is built without one.
    2. SpecificationWritten and testable. Approved by a person before work starts.
    3. Tests firstWritten from the specification and proven to fail before any code exists.
    4. Blind buildThe code is written from the specification. The builder never sees the tests, so it cannot write code that only satisfies them.
    5. Review gateFull test suites, build, security and code review on the whole change.
    6. Staging checkDeployed and exercised for real: in a browser, a mobile simulator, an API sandbox or a containerised environment, with evidence attached to the ticket.

    Anything found on staging goes back in as a new specification, test and fix.

    Where people decide

  • A person approves every specification.
  • A person approves every commit and pull request.
  • A person decides what reaches production.
  • Your contact is always one of our engineers, never a bot.
  • What makes it different

  • Separation of duties. The agent that writes the tests never writes the code, and a third one reviews. A lead agent plans and checks every result, and our engineers direct the work.
  • Specialists in parallel. Several agents work at the same time on separate slices of the same change: mapping the codebase, writing tests, building, reviewing. This is where the speed comes from.
  • The same gates for people and agents. One set of checks for every change, whoever wrote it. A change that edits the tests or the pipeline together with the feature is blocked automatically, so nobody reaches green by weakening the check.
  • One thread from request to release. Requirement, ticket, specification, commits, pull request, deployment and test evidence are linked. You can follow any change back to the request that asked for it.
  • Everything on record. Specifications, decisions, test results and status live in the repository and the project wiki. Nothing important lives only in a chat history.
  • Guardrails

    Agents are fast. The rails decide where they can go.

    Agents canAgents cannot
    Read and change code in an isolated copyTouch production systems or production data
    Run tests and buildsPush to protected branches
    Deploy to a development environmentChange tests or build settings while implementing
    Read logs to diagnose a problemCommit, merge or release without a person's approval
    Open pull requests and update ticketsCommit secrets or credentials

    Every agent works under one written operating policy. Retries are bounded: a fix that keeps failing goes to a stronger model or to a person, never round in circles. Every environment change goes through the pipeline as reviewed code.

    Security, built in

    Platforms we build with the factory are watched for newly published vulnerabilities that affect their components, and attacked from the outside in regular AI-driven penetration drills. Every relevant finding goes back through the same line: ticket, test, fix, review, and a re-check on the next drill.

    What you own

  • Specifications, tests, operating policy and code. In your repository, under your organisation, from the first commit.
  • Your infrastructure. The factory works on your cloud account or your own servers.
  • Your choice of model. The factory is model-neutral. Changing the model provider is a configuration change; the specifications, tests and code stay exactly as they are, and the same tests decide what is correct whatever model wrote the code. Each task runs on the cheapest model that does it well, and EU-hosted models are available.
  • Your data stays out of prompts. Agents work on code and specifications, never on your customers' data.
  • Proof

    Two engineers, one client platform, since May 2026

    9epics shipped
    169features and tasks shipped
    ~7,400automated tests on every change
    215pull requests merged
    40merged in the last 30 days
    28deployments in the last 30 days

    A 22-item client review, delivered the same day. A private-markets fintech sent a review document with 22 items and 34 screenshots: bug fixes, new search, a new front page and a server-side matching engine for more than 50,000 records. In one working session the team of two took it from their document to verified software on staging: root causes mapped, one specification with four decisions by the product owner, tests and code built in parallel, four review findings fixed, every item re-checked in a browser. Including a second fix round.

    A regulated lender's core platform. A team of five runs the factory on the replacement lending platform for a consumer lender supervised by its national central bank, on the client's own servers and in the client's own code organisation. The factory runs inside a security-hardened pipeline: architecture tests that fail the build when a module boundary is crossed, a coverage floor that can only go up (above 99% today), signed container images and a bill of materials on every release. The foundation milestone has been in delivery since September 2026, and bug fixing has taken 0.7% of the planned effort so far.

    A finance automation platform for BPOs. Finance automation, consolidation and reporting, tuned for business process outsourcing groups that run many legal entities in many currencies. Three developers have built and run it in production with the factory since April 2026: 10 epics and 417 features and tasks shipped, more than 1,200 commits, more than 100 architecture decision records, and a specification approved before every new requirement.

    A software team that wanted to know why features took so long. A small European B2B software company asked us to measure before prescribing. Two weeks of read-only analysis of six months of their delivery data found a median of 11.7 days from start of work to production. Coding was 16% of that time. Manual testing was 64%. The factory is now installed on their repositories, and their engineers work their own backlog in it, led by our tech lead. The same numbers are measured again after twelve weeks.

    More in our case studies.

    Two ways to work with us

    1. We build it for you

    A small team of our engineers runs the factory on your product, sized to the work: a new platform, a module, a backlog that has stalled, or a rebuild. You approve the specifications, see every change as a pull request and decide what is released. Suited to startups building their first product, companies without an engineering team, and teams that are fully booked.

    2. We install it in your team

    For companies that have developers and want them to work this way.

    StepWhat happens
    Assess (2 weeks)Interviews and read-only access to your repositories, pipelines and tickets. A measured baseline of how work moves from ticket to production, a readiness score for working with agents, and a roadmap where every step has an expected gain and an effort.
    Install (about 12 weeks)The factory on your repositories. Your team works its real backlog in the new flow from the first week, pairing with us on real tickets. The baseline is measured again at the end.
    Lead (ongoing)The senior who ran the assessment leads the rollout and stays as your tech lead, so the change holds after we step back.

    Reporting is in plain language: days, counts and euros, one page every two weeks.

    We do not promise a percentage before we have measured your baseline. You get a number from your own data first, and the gain is reported against it.

    Also: fix and rebuild

    Findings from a security audit, a penetration test or a code review, fixed through the factory as scoped, fixed-price work.

    Who it is for

  • Companies without a senior technical lead who need software built and run properly without hiring one.
  • Small software teams that feel features take too long and want a measured answer.
  • Regulated businesses (finance, healthcare, compliance-heavy operations) that want AI-speed delivery with an audit trail on every change.
  • Startups that need to build fast and cannot afford to bolt quality and security on later.
  • Product owners with a backlog and a deadline.
  • Large-team speed, regulated-team discipline

    Tell us what is in your backlog, or what is taking too long, and we will show you what the first two weeks would look like. Contact us or write to blooming@looming.tech.

    Frequently asked questions

    Does AI write our code unsupervised?

    No. Our engineers direct the agents, a person approves every specification and every pull request, and nothing reaches production without an explicit release decision.

    Which AI models do you use?

    Whichever does each task well at the lowest cost. The factory is model-neutral, so new model generations slot in without rework, and switching provider does not touch your code or tests.

    Does our code or data leave our control?

    Code stays in your repository. Agents never get access to production systems or customer data. EU-hosted models are available where your policy requires it.

    How much faster will we be?

    We measure first. In a two-week assessment we put a number on how long a change takes today and where the time goes, and report the gain against that number.

    What do you need from us to start?

    A conversation about your product and backlog. For an assessment: a few interviews and read-only access for two weeks.