Software factory
We build a software factory around your delivery process: structured specifications go in, and consistent, tested, reviewable packages come out, with people approving every stage and every change recorded.
A governed, AI-assisted delivery pipeline that turns specifications into tested, reviewable software through templates, staged generation and human approval gates.
- Template-based code generation
- Staged generation passes
- Dry, mock and live test runs
- Auto-fix loop
- Python
- FastAPI
- Angular
- REST and server-sent events
- Docker or Podman containers
- Git and pull requests
- Azure Pipelines
- Dependency manifests
The challenge
Software that follows the same pattern is still built by hand, one project at a time. Each team writes its own structure, its own tests and its own deployment scripts, so effort repeats and quality depends on who happened to build it.
Pointing an AI model at the problem without structure makes it worse. Free-form generation produces code that looks plausible but differs from project to project, is hard to review and is rarely tested before it reaches a pipeline.
What it does
Specification capture
Requirements are recorded as structured inputs such as sources, fields, rules and mappings, so every build starts from a reviewed, machine-readable specification rather than free text in a ticket.
Template-driven generation
Tested templates define the shape of every package. The model fills in parameters inside that shape, which keeps output consistent and far easier to review than free-form code.
Staged multi-pass build
Generation runs in ordered passes: core modules, then rules and transforms, then architecture and security review, then deployment files. Each pass builds on a checked result.
Test and self-repair loop
Generated code is syntax checked, dry run, then tested against real or mock data. When a run fails, the model proposes a targeted fix to the failing file and the run repeats.
Review gates
People approve discovered inputs, rules and mappings before code is generated, and review the generated files before they move on. Nothing advances without an explicit decision.
Publish and deploy
Finished packages are pushed to a Git repository on a feature branch for pull request review, and ship with container and dependency files so a pipeline can build them.
How it works
Capture the spec
Analysts define sources, fields, rules and mappings in a guided workspace. AI suggestions are proposals only, and each item is approved before it counts as part of the specification.
Generate by template
The factory assembles the approved specification and reference material into a prompt and builds the package in staged passes, producing a consistent set of files every time.
Test and repair
Each package is checked, dry run and exercised against mock or live data. Errors feed the repair loop, and results are stored against the build for later comparison.
Review and publish
A reviewer inspects the files and results, then publishes to a feature branch in Git for the normal pull request and deployment pipeline.
Under the hood
- Delivery pipeline
- Template-based code generation
- Staged generation passes
- Dry, mock and live test runs
- Auto-fix loop
- Application
- Python
- FastAPI
- Angular
- REST and server-sent events
- Packaging and release
- Docker or Podman containers
- Git and pull requests
- Azure Pipelines
- Dependency manifests
- Data and models
- PostgreSQL
- Anthropic or Azure OpenAI models
- Reference document library
Business outcome
Consistent output every time. Every package has the same structure, files and conventions, so teams can review, maintain and hand over software without relearning each project.
Faster, less repetitive delivery. Repeated engineering work moves into templates and pipelines, so people spend their time on specification and review rather than rewriting the same scaffolding.
Quality gates before release. Software is checked, tested and reviewed before it reaches a repository, which reduces the chance of unreviewed or untested code entering a pipeline.
Traceable from request to code. Each delivered package links back to its approved specification, test results and publish record, which gives auditors and engineering leads a clear trail.
Where it is used
- Building a family of similar services or integration packages from one set of templates and reviewed specifications.
- Standing up an internal delivery pipeline where AI generation, testing and review sit in one governed workflow.
- Adding automated test generation, repair and release checks to an existing engineering team's process.
- Moving repeatable build work from ad hoc scripts into a documented, auditable and reusable factory.
Frequently asked questions
Does the AI write all the code?
No. Templates define the structure and the model fills in parameters within it. People approve the specification before generation and review the output before it is published.
Which AI models can the factory use?
The model layer sits behind a single provider abstraction, so teams can choose among frontier models and their own approved deployments, and switch without changing the pipeline.
Where does the generated software go?
Packages are pushed to a Git repository on a feature branch, ready for your own pull request review and deployment pipeline. Your repositories and your release process stay in control.
Is this a product or an engagement?
It is a service. We design the templates, stages and review gates around your delivery process, run the first builds with your team, and hand over a factory you can operate.
See it on your own documents and data
Tell us what you want to automate and we will show you how it runs inside the harness.