A dark factory for software.
Table of contents
Background coding agents
Describe the task. Get back a pull request that proves it works.
Darkshift is a dark factory for software. You describe a change in plain language. An isolated AI coding agent implements it, runs your repo's own checks, and QAs it in a real browser with the session recorded. Most tasks finish in 5 to 30 minutes, and the pull request is waiting when you look. No local dev environment, ever.
$99 per user per month, plus model usage at the provider's rates. See pricing.
The name
The factory floor is dark. The output isn't.
A dark factory is manufacturing's term for a plant that runs unattended, lights off, because nobody is on the floor. That is what a software factory becomes when the work no longer needs your laptop open.
Darkshift runs the shift nobody is staffing. Lights out on the line, evidence on every pull request.
Why this exists
Ramp and Uber built their own. You can plug one in.
| ~40% | of merged PRs at Ramp are written by their in-house agent | Ramp · Inspect |
| ~1,800 | agent-written changes shipped per week at Uber | Uber · Minion |
| 90% | of the Fortune 100 use a background coding agent | GitHub · Copilot |
| 180+ | features shipped across Darkshift, Hashnode and Bug0 in two weeks | Darkshift · July 2026 |
How it works
Task in, pull request out.
The PR is the approval gate, so there is no new workflow to adopt: work arrives where your team already reviews it. Fig. 1 above is the whole line; the three figures below are detail views of each station.
1
Describe the task
Describe it in plain language, or feed it in from Linear: a ticket becomes a task. Point Darkshift at one repo or several, and pick the AI coding agent per task: Claude Code, Codex, Grok Build, or Kimi Code.
2
The factory works
An isolated sandbox clones your repos and implements the change. It runs your repo's own checks and fixes its own failures, up to 3 attempts. Then it re-reads the diff the way a skeptical reviewer would, and QAs any UI change in a real browser, recorded.
3
Review evidence-backed PRs
One pull request per changed repo, with the QA recording attached. Follow-up messages stack commits onto the same PRs.
Most tasks finish in 5 to 30 minutes, depending on size. The run is server-side, so you can close the tab and it finishes without you.
- Several repos at once
- One task can touch the API and the frontend. Each changed repo gets its own pull request.
- Several tasks at once
- Every task runs in its own isolated sandbox, so queue as many as you like.
- Your pick of agent
- Claude Code, Codex, Grok Build, or Kimi Code, chosen per task.
- QA behind your login
- Sign in to your app once; later runs test the signed-in pages too.
Where work comes in
Work comes in the way it already does.
From a PRD to a pull request: work enters the factory the way it already enters your team, as specs, tickets, and logged bugs. It leaves as PRs.
- Work in
- Linear, Jira, Slack
- Code out
- GitHub
- Agents
- Claude Code, Codex, Grok Build, Kimi Code
PRD → PR
Hand it the spec
Paste a PRD as the task. The factory implements it across every repo it touches and opens one PR per changed repo.
Ticket → PR
Point it at the board
Connect Linear or Jira: a labeled ticket becomes a task, and the finished PR lands back on the ticket, ready to review. Or tag the agent in Slack.
Bug → PR
Route it the bug
A logged bug becomes a fix run: the factory patches, re-runs your checks, QAs the fix in a real browser, and the PR is ready to review and merge.
As for what it runs on: any repo Darkshift can clone, install, and run your checks against. You give it the setup and check commands once, on the Repos page, and every future run follows them.
FAQs
Built for the questions your team will ask.
What does it cost?
$99 per user per month. That is the platform: tasks against your connected repos, isolated sandboxes, recorded browser QA, and the pull requests. Model usage is separate and paid one of three ways: metered at each provider's published rates with no markup, or on your own API key, or on a Codex subscription you already pay for.
Does it work with our stack?
If your repo builds and tests on a Linux box, it runs here. You register setup and check commands once per repo, plus any environment variables it needs, and every future run follows them. Darkshift connects through a GitHub App you scope to the repos you choose.
Can the agent see our secrets?
No real credential ever enters the sandbox. The agent's CLI runs on a placeholder. Real model keys and GitHub tokens are injected into outbound requests in transit by the sandbox firewall, and each repo gets its own token scoped to that repo alone. There is nothing in the VM to exfiltrate.
What happens when it gets something wrong?
You close the pull request. Darkshift never merges and never pushes to your default branch. A run that changed nothing opens nothing. The worst case is a branch you delete, and the PR description tells you upfront what it did not verify.
“Agent PRs are slop.”
Every PR ships with evidence. Your repo's checks run with fix attempts, the agent self-reviews, and UI changes are QA'd in a real browser with the recording attached to the PR. Reviewers can watch the change working before they read the diff.
“We could build this ourselves.”
You could. It costs a platform team. Sandbox infrastructure, image caching, credential plumbing, browser QA, then permanent maintenance. Darkshift is a GitHub App you connect today.
“An agent doesn't know our codebase.”
The agent improves with every task. Key decisions and caveats from every run persist to a team-wide shared memory, so the next task starts smarter, for everyone on the team. Seed it by importing shared context from Notion, Jira, or Linear.
The full list
Everything the factory does.
- Task in, PRs out. Submit a task and close the tab; the finished pull request waits for you.
- Recorded browser QA. Every UI change ships with a video of it working in a real browser.
- Parallel tasks. Every task runs in its own isolated sandbox, so queue several at once.
- QA behind your login. Sign in to your app once; later runs test the signed-in pages too.
- Follow-ups on the same PR. Reply like you would to a teammate and new commits stack on.
- Your checks decide done. It runs your repo's lint, types, and tests, and fixes its own failures before you see a PR.
- Multi-repo tasks. One task can touch the API and the frontend; each changed repo gets its own PR.
- Intake from anywhere. A Linear ticket, a Slack mention, a screenshot, or a plain sentence.
- Your pick of agent. Claude Code, Codex, Grok Build, or Kimi Code, chosen per task.
- Bring your own keys. Add your Anthropic, OpenAI, Azure OpenAI, xAI, or Kimi key, or connect a Codex subscription; the provider bills you directly.
- It can't wreck your repo. No merging, no pushing to your default branch; the worst case is a PR you close.
- PRs that explain themselves. Every description carries a summary, verification steps, and honest caveats.
- No junk PRs. A run that changed nothing opens nothing.
- House rules, remembered. Per-repo notes and commands that every future run follows.
- Live narration. Watch the agent reason through the work in plain prose, or check back later.
- Nothing to install. No CLI, no plugin, no local checkout; any browser works.
- Grant one repo to start. Access is a GitHub App install you scope and revoke in GitHub.
- Self-improving agent. Key decisions and caveats from every run persist, so the next task starts smarter.
- Team collaboration. Invite teammates by email; everyone shares the team's repos, runs, and history.
- Cloud MAX. Our name for the whole point: no local dev environment at all, the entire workflow runs in the cloud.
The creators
We built it to run our own companies.
Darkshift runs Hashnode, one of the largest developer publishing platforms, and Bug0. It started as the internal factory that kept both shipping with 1 or 2 engineers, built by the team behind them, and that factory became the product.
Your backlog isn't getting shorter.
Book 30 minutes and watch Darkshift clear a real ticket from your repo, live.
$99 per user per month, plus model usage at the provider's rates. See pricing.