Turn your backlog into pull requests with an AI software factory
We connect your ticketing tool, GitHub and an AI coding agent into one workflow. Tickets go in, tested pull requests come out, and your team approves every merge.
Starts with one repository. Your code stays in your GitHub.
Tested with
- Jira
- ClickUp
- GitHub
- Claude Code
- GitHub Actions
Your team has AI tools. Your backlog hasn't moved.
Tickets travel by copy and paste
Developers copy tickets into chat windows and paste code back out by hand. The tool that knows the requirement and the tool that writes the code never talk to each other.
Every AI change still needs a human courier
Someone has to test it, review it, open the pull request and link it back to the ticket. The writing got faster. The delivery did not.
Nothing is repeatable across the team
Each developer prompts differently, keeps their own rules in their head, and gets different results. What works for one person cannot be handed to the next.
A software factory turns those one-off prompts into one connected, repeatable workflow.
What a software factory does for your team
A software factory connects the tools your team already uses into one loop. A ticket goes in, an AI coding agent writes the change and opens a pull request, automated tests check it, and your team approves the merge. Your developers stop hand-carrying work between tools and spend their time on review and the hard problems.
We build light factories: a person always approves the merge.
New to the idea? What a software factory isHow the software factory flow works
- 01
Ticket
A ticket with acceptance criteria is moved to a start column in Jira or ClickUp. That move is the only trigger.
- 02
AI writes code
The agent reads the ticket, your project rules and your codebase, then makes the change in a clean, isolated environment.
- 03
Pull request
It opens a pull request on your repository, linked to the ticket, with a plain summary of what changed and why.
- 04
Tests and review
Your CI runs the test suite and checks. Failures go back to the agent, which fixes and tries again.
- 05
Your approval
A person on your team reviews the pull request and approves the merge. Branch protection stays exactly as you set it.
- 06
Deploy and update
Your existing deploy runs, and the ticket is updated with the result. Status flows back to where the work started.
Failed test, fix, test again. Clear requirements and reliable tests make the factory useful.
What's inside your software factory
Project rules and skills
Your conventions, written down so the agent follows them: how you name things, how you test, what never gets touched. Reusable skills for the tasks your team repeats.
Ticket sync
Tickets start the work and status flows back. Nobody copies a requirement into a prompt, and nobody updates a board by hand after a merge.
Isolated runs
Every task runs in a clean environment with a fresh checkout, not on a laptop. The run can be inspected, repeated and thrown away.
Tests and checks
Nothing reaches review without passing your suite, your linters and whatever checks you already require on a pull request.
Approval gates
Your branch protection and release rules are the gate. The agent can open a pull request. It cannot merge one.
Access and audit
Least-privilege tokens that you issue and can revoke. Every change is a pull request with a full history of who asked, what ran and who approved.
Works with the tools you already use
We mark each tool honestly. Tested means we have run the full loop with it. On request means we scope the connector as part of your setup.
| Area | Options |
|---|---|
| Tickets |
|
| Code |
|
| AI agent |
|
| CI |
|
| Chat and more |
|
Area
Tickets
Options
- JiraTested
- ClickUpTested
- TrelloOn request
- LinearOn request
Area
Code
Options
- GitHubTested
- GitLabOn request
Area
AI agent
Options
- Claude CodeTested
- The agent that fits your stackOn request
Area
CI
Options
- GitHub ActionsTested
Area
Chat and more
Options
- SlackOn request
- Other tools, on demandOn request
How our software factory setup works
- Sample
1. Connect
We link your ticketing tool, your GitHub organisation and the AI coding agent, using tokens you issue with the minimum access needed.
- Sample
2. Adapt
We write the project rules and skills for your codebase: conventions, test commands, forbidden areas, and the definition of done your tickets already imply.
- Sample
3. Protect
We wire tests, review requirements and release controls into the loop, so a pull request that fails a check never reaches a reviewer.
- Sample
4. Hand over
You get the documented loop, a recorded walkthrough and a team that can change any part of it without us.
We start with one repository and one workflow. Once it works, we add more.
Get my software factory set upYou decide how much the agent does
Autonomy is a dial, not a switch. Every team starts at the first stage and moves only when its tests justify it.
- We start here
Every change approved
The agent opens pull requests and you review each one. We start here, always.
Exceptions only
Routine changes that pass every check get a light review. Anything unusual gets a full one.
Auto-merge on green
Only for low-risk changes you choose, such as dependency bumps or copy fixes, and only once your test suite has proven itself.
You move to the next stage when your tests earn it, not before.
Your code, your controls
- Code stays in your repositories and your accounts.
- The agent gets the minimum access it needs, through tokens you can revoke at any time.
- Secrets stay in your secret store. They never appear in prompts.
- Every change is a reviewable pull request with a full history.
- You choose the AI provider and read its data terms before anything runs.
Try it free
The software factory starter
A generic sample you can run on your own GitHub account to see the loop end to end before you talk to us.
You get
- A sample ticket with acceptance criteria
- Setup steps for the agent and the workflow
- One reusable skill
- A test checklist
- The expected result, so you know it worked
Merge and deploy approval stay with you. The sample contains no client code and no secrets.
Get the free starterIs your repo factory-ready?
Ten yes or no checks. If you answer no to more than two, the checklist tells you what to fix first.
- Tests run automatically in CI on every pull request
- Tickets have written acceptance criteria
- Branch protection is on for the main branch
- A README explains how to set up and run the project
- Secrets live in a secret store, not in the repository
- One command installs dependencies and runs the project
- Linting and formatting are enforced automatically
- A named person can approve merges
- Deploys are scripted, not done by hand
- Every ticket has a clear definition of done
See a software factory working
One recorded run of the loop, from a ticket to a merged pull request, with nothing cut.
01
The ticket
A ticket with acceptance criteria is moved to the start column.
02
The run
The agent works in an isolated environment and opens a pull request linked to the ticket.
03
The checks
Tests and checks run on the pull request in CI, and the ticket shows the status.
04
The approval
A person reviews, approves and merges. The ticket moves to done.
Build it yourself, buy a platform, or have it set up
| Build it yourself | Buy a platform | Software factory setup | |
|---|---|---|---|
| Uses your current tools | Yes | Partly | Yes |
| Time from your team | High | Medium | Low |
| New vendor to pay | No | Yes, per seat | No, one setup fee |
| Fitted to your codebase | If you do it | Partly | Yes |
| You own the result | Yes | No | Yes |
Uses your current tools
- Build it yourself
- Yes
- Buy a platform
- Partly
- Software factory setup
- Yes
Time from your team
- Build it yourself
- High
- Buy a platform
- Medium
- Software factory setup
- Low
New vendor to pay
- Build it yourself
- No
- Buy a platform
- Yes, per seat
- Software factory setup
- No, one setup fee
Fitted to your codebase
- Build it yourself
- If you do it
- Buy a platform
- Partly
- Software factory setup
- Yes
You own the result
- Build it yourself
- Yes
- Buy a platform
- No
- Software factory setup
- Yes
Software Factory
A software factory is a workflow, not a product. We build it inside the tools you already pay for.
What you get at handover
- A working ticket-to-pull-request loop on your repository
- Project rules and reusable skills, in your repository
- Test and approval gates wired into your CI and branch protection
- Written documentation for your team
- A recorded walkthrough call
What you'll be able to see
We set up the tracking. We promise no figures.
Tickets turned into pull requests
Check pass rate
Time from ticket to pull request
AI spend per pull request
The numbers are yours to read, in your own tools, from the first week.
How pricing works
Fixed setup quote after a 30-minute call. No per-seat platform fee.
Running costs, meaning your AI plan or API usage and CI minutes, are paid directly to the providers.
Who software factory setup is for
A fit
CEOs, founders and startups who want to cut the cost of engineering headcount to less than half, and development teams that want to accelerate: several projects at once, without losing focus, with a person still approving every merge.
Not a fit yet
Teams with no tests or no written requirements. The checklist shows what to fix first, and we are happy to say so on the call.
Who sets up your factory
Every setup is run by the founder or by a senior engineer who specialises in software factory setup, and who builds and runs these loops on our own projects.
About the founder and the studio- One engineer owns your project from the first call to handover.
- The same engineer records the walkthrough your team keeps.
- No account managers between you and the person doing the work.
Questions about software factory setup
Do we need to replace our current tools?
No. The factory is built inside the tools you already use: your ticketing tool, your GitHub organisation and your CI. We add rules, automation and an AI coding agent between them. If a connector you need is not yet tested, we tell you before the project starts, not after.
Which tools does it work with?
Jira, ClickUp, GitHub, Claude Code and GitHub Actions are tested. Trello, Linear, GitLab, Slack and other coding agents are available on request, and most tools with an API can be connected on demand: we scope the connector as part of your setup. Every tool on this page is marked so you know what is packaged and what is custom.
Who approves the code?
Your team does. The agent opens a pull request and never merges on its own. Your existing branch protection, required reviews and release rules stay in place. We start with every change approved by a person and only loosen that for low-risk changes you choose, once your tests have earned it.
We already use Claude Code or Copilot. Why a factory?
An assistant helps one developer write code faster. A factory connects the whole loop: the ticket starts the work, the agent runs in a clean environment, tests check the result, and status flows back to the board. The difference is repeatability across the team, not a better autocomplete.
Can we start with one repository?
Yes, and we insist on it. The first setup covers one repository and one workflow, such as bug fixes from a single board. Once that loop runs reliably, we extend it to more repositories or ticket types. Starting small keeps the risk low and makes the result easy to judge.
What does it cost to run?
Three things: your AI provider plan or API usage, your CI minutes, and the tool subscriptions you already have. You pay each provider directly and see every invoice. We set up tracking of AI spend per pull request so the running cost is never a guess. Provider pricing pages are linked on this page.
Is our code safe?
Your code stays in your repositories and your accounts. The agent receives the minimum access it needs through tokens you issue and can revoke. Secrets stay in your secret store and never appear in prompts. Every change is a reviewable pull request with full history, and you choose the AI provider and its data terms.
What do we have at the end?
A working ticket-to-pull-request loop on your repository, the project rules and reusable skills that drive it, test and approval gates, written documentation, and a recorded walkthrough for your team. Everything lives in your accounts, so the result is yours whether or not you work with us again.
What if our tests are weak?
Then the factory is not ready yet, and we will tell you. Reliable tests are what make an agent's pull requests safe to review. The free checklist shows what to fix first. In many cases the first phase of a setup is adding the tests the agent needs, so the gate means something.
How long does setup take?
It depends on what your repository already has and how many workflows you want. We give a fixed duration with the quote after the first call, once we have seen your tests, your tickets and your tools. A first workflow on one repository is scoped as a short project with a dated handover, not an open-ended engagement.
Get your software factory set up
Tell us where the work gets stuck. We reply within two working days with a short set of questions, then a fixed quote after a 30-minute call.
[email protected]