Engine developer
Writes the core product logic.
The Software Factory
Runs at AI speed, guided by a senior team.
A structured, AI-enabled delivery system we build and run for you. A fleet of AI agents writes, reviews, tests, and ships software, under the direction of a senior engineer, a product owner, and you.
What It Is
The Software Factory is a delivery system we build and run for you. It takes a written specification and produces working, production-ready software: new products, features or modules added to an existing codebase, prototypes hardened to production quality, platform migrations and compliance rewrites, and integrations that span several systems. It is also how we estimate level of effort and find the roadblocks in a large initiative before it starts.
It is more than a reference setup. It is designed to overcome the weaknesses of unsupervised AI development — bias, blind spots, hallucinated architecture, and suspect foundational decisions — by keeping experienced people in control of what gets built and how. Every engagement is led by a senior engineer and a product owner, so the speed of AI never runs ahead of the judgment that keeps the work sound.
The Team
Every engagement is staffed with at least two of our senior people. They are named, and they are accountable for what the Factory ships.
- OperatorSenior engineer
- Runs the agent pipeline and takes on the hard technical problems: edge cases, integrations, and security. Gives final approval on every architecture decision.
- Planner and QA coordinatorSenior product owner
- Turns your priorities into scoped work, runs independent verification and testing, manages the trade-offs, and is your primary point of contact.
Scope, complexity, and support needs can call for more people. Two is the floor, not the target.
How It Works
The Factory coordinates a fleet of AI agents in two layers. An orchestrator reads each task, decides which specialist should handle it, and assembles the results. Each specialist does one kind of work, with access only to the tools that work requires.
Frontend developer
Builds the client-facing interface.
Test author
Writes automated tests alongside the code.
Reviewer
Checks code for bugs and standards.
Architect
Approves or blocks structural decisions.
Coordinator
Handles work that spans several areas.
- Reviewers and architects cannot change code, so no agent approves its own work.
- Only the orchestrator assigns work, which keeps the fleet from looping.
- Specialists run in parallel, so multiple workstreams move at once.
Council Mode
For load-bearing decisions — architecture, security-sensitive choices, scope, a dependency, a public interface — no single agent decides alone. A position is put forward, a critic built on a different AI provider family attacks it, the original agent rebuts, and a person arbitrates the result before it is locked.
No single agent locks in a load-bearing decision.
Model families share training data and benchmark exposure, so they tend to make correlated mistakes and sample the same blind spots. A second opinion from the same family is not a second prior. Making provider diversity structural means the reviewer most likely to catch a confidently wrong answer is the one least likely to share its author’s blind spot.
The fleet draws on Claude (Anthropic), GPT (OpenAI), Qwen (Alibaba), and DeepSeek, among others. Different providers take different roles — orchestration, bulk execution, and independent critique — so no single vendor’s blind spots decide your delivery.
It also means the execution and critique work is not dependent on any one provider: if a provider has an outage or changes its pricing, that work routes around it automatically. The orchestrator is the deliberate exception — it stays on Anthropic for its long-horizon context management.
Proof in Production
Two real engagements. We took out the client names and nothing else.
A live production system we did not build
A financial-analytics platform serving portfolio values, returns, and holdings over an API, on three data stores with three different consistency models, still carrying client-visible drift from an old migration.
- A holding reporting a price return of −100% on an asset that was actually up. We traced it to returns being rolled up from a different store than values, and corrected it to +38%, consistent with the value-based return.
- Roughly 190,000 data points reconciled across the full hierarchy. The state was snapshotted first so the operation stayed reversible, then verified to the cent at every level.
- An alarm reporting thousands of failed jobs, where 94% of the backlog was stale fallout from a bug already fixed. The blind mass-retry that would have re-corrupted client data was refused.
The hard part of production is not writing code. It is understanding a system you didn't build, changing it safely, and proving you didn't break it.
A prototype taken the rest of the way
An internal operations app — workforce planning, time-tracking, role-gated finance views — generated with AI on a hosted Postgres database, taken to secure, compliant, production-grade software.
- A prototype that looked finished was leaking data across users: change the ID in the URL and you could edit another user’s records, an authorization check failed open, new users were created with no role, and managers held global write instead of scope to their own reports. Each one fixed and covered by a test.
- Eighteen raw CSV files migrated in strict dependency order and reconciled row for row. “Done” meant every table was reconciled, not that the script finished.
- A full security review mapped to the OWASP Top 10 and SOC 2 common criteria, with a role-by-role authorization matrix proving the access rules as a tested property.
Prototype builders will get you a working app in a weekend. The part that decides whether a product survives real users is the part they do not do.
What You Get
Every engagement produces working software committed to your repositories, along with the evidence that it meets what was agreed. What we have built this way includes multi-tenant SaaS platforms with role-based access control, care-planning and case-management workflows, real-time messaging, billing integrations, REST and GraphQL APIs, authentication and authorization systems, and data import and export pipelines.
Application code
Full-stack software on React and Next.js, with Node.js or Python behind it and TypeScript throughout, built in numbered, testable iterations. Every contract item is mapped to the iteration that delivered it, in a scope coverage report.
Infrastructure
Build, test, and deploy pipelines, hosting and environment configuration, database provisioning, and monitoring, all documented in a runbook.
Security
Dependency scanning and code-level review on every iteration, with security-sensitive code checked by a reviewer from a different model family than the one that wrote it.
Automated testing
Unit, integration, and end-to-end tests written alongside the code and run on every commit. Nothing is marked delivered until they pass.
Verification packet
A structured archive that documents what was built and proves it meets the agreed scope: technical deliverables, quality evidence, a decision log, and the runbook.
Existing Codebases
The Factory works on code it did not write.
On an existing codebase there is a ramp-up period before any shipping begins, while the team maps what is already there: the product, the features, the architecture, the conventions, and the known issues. That work is not something you pay for twice. The decision log from the ramp-up becomes part of the permanent record for your engagement, so what we learned about your system stays with you.
How You Work With Us
You talk to the Factory in a dedicated Slack channel. There is no portal, no ticketing system, and no standups to attend.
- You send a request in plain language: a new feature, a bug, a change to how something behaves.
- A bot watches the channel continuously and picks it up, including replies on older threads.
- The request becomes a tracked item, and you are notified on every update.
- The Factory works it and replies with status, output, and any questions that need your input.
- Working software lands in your repository when the item is done, with a note on what changed.
One request is handled at a time, and it is only marked done once the work has actually succeeded. If something goes wrong the request stays on the list and is retried. Nothing is silently dropped.
The Factory comes to you only for the decisions that need your judgment: product trade-offs, design choices, priority calls, and gate approvals. Everything else is handled without you.
Trust and Data
Your code and your data stay under controls set before any work begins.
- Each engagement runs in its own isolated environment on Ballast Lane infrastructure, never a shared public cloud, with client credentials kept separate.
- AI workers get only short-lived, task-scoped access. There are no standing connections into your systems.
- Model usage runs under API terms that do not use your inputs or outputs for training. Where a provider does not meet that bar, we exclude it if your security policy requires.
- Every model call passes through a single recorded layer, so we can show you exactly which model touched your data, when, and what changed.
- For sensitive engagements, key data handling can run on self-hosted models on Ballast Lane hardware, so your code and data never leave.
- The full data posture is set per engagement and governed by contract before work starts.
What You Own
Everything the engagement produces is yours, in formats you can read without us.
- All code in your repositories, along with the verification packet, the runbook, and the decision log.
- No key-person dependency on Ballast Lane staff. Any competent engineering team can pick up the codebase from the documentation delivered with it.
How to Engage
Where you start depends on what you have today. You can pick one entry point or move from one to the next.
Prove it on a real project
For any team that wants to see the capability before committing to it.
One delivery cycle, led by us, on a real product of yours, taken to a real, evidenced outcome. The lowest-risk way to watch the Factory work: you finish with working software and a verification packet in hand, not a pitch.
We become your engineering team
For a founder or company that needs to ship but has no engineering organization, and does not want to spend a year building and managing one.
We run as your delivery engine. You set direction and priorities; the Factory plans, builds, tests, secures, and ships against your roadmap, with senior judgment on every architectural call and a verification packet behind every release.
Level up your own team
For an engineering organization that has fallen behind on AI and needs to catch up without betting the company on it.
We embed AI-enabled product owners, designers, and engineers directly into your teams, where they ship real work and transfer the practice by example. Your people learn by building alongside someone who already does it well, and the capability stays after we leave.
Own your factory
For a capable engineering organization that wants to run AI development in-house.
We set up a factory tuned to your stack and standards, transfer the operating model to your people, and hand you the keys. You get the blueprint and the hard-won lessons instead of paying to rediscover them.
Read the Detail
The full capability overview, and the two engagements above written up in full. No form, no email capture.