I write fewer lines by hand than I did two years ago and ship more. Most of that comes from the loop around the model: what goes in, what has to be true before anything is committed, and where I step in.
The daily loop
- Spec first. I talk the feature through with the agent until the open questions are answered, using Matt Pocock's grilling and PRD skills, then split it into vertical slices with one issue file each.
- One fresh session per issue. My implement-issue skill takes the next unchecked issue, writes the test before the code, and runs the type checker and the touched tests after every step. Then it opens the app in a real browser through Chrome MCP or Playwright and clicks through the change. A stricter variant requires black-box end-to-end tests and forbids asserting against a response shape the agent has not actually seen.
- A reviewer that did not write the code. A second agent
reads the full diff. At Rogii I packaged this as
fe-review, a Claude Code plugin in our team marketplace. Three reviewers run in parallel: one checks the ticket's acceptance criteria, one checks our architecture rules and ADRs, and one looks for runtime cost such as query keys, effects and render work. A finding that cannot be traced to a line is dropped. A red lint, type or test check rules out approval. - One commit, a manual test note, my review. The agent writes down what changed and how to check it by hand. I read every diff before it merges.
At work the agent reaches Jira, GitLab and the internal docs through MCP, and each ticket gets its own git worktree, so several sessions can run without stepping on each other.
Dark Factory: the loop without me in it
Running issues one at a time still needed me to start every session. Dark Factory is a small local app, a Node and Express backend with a React UI over server-sent events, that takes a queue of issues and runs each one through headless Claude Code. The agent is told to implement and never touch git. The orchestrator owns git, so every issue becomes exactly one commit and one rollback point.
| When the session ends with | Dark Factory |
|---|---|
| Exit 0 and the issue's verify command passes | commits, moves to the next issue |
A final message starting with NEEDS_INPUT: | stops, shows me the question, resumes the same session with my answer |
| An error, a red check, a crash or the 30-minute timeout | commits nothing and halts the whole queue |
Two decisions worth explaining:
-
It shells out to the
claudeCLI instead of using the Agent SDK. The SDK only accepts API keys, and I wanted the runs to count against my subscription. - The design said to pause at 80% of the usage limit. Once it was built, it turned out the CLI does not expose a usage percentage at all. The throttle now listens for the CLI's rate-limit events instead: it lets the current issue finish and commit, stops, and resumes at the reset time the event reports.
A test run
I gave it an empty folder and nine issues. The first scaffolded a React app. The second asked the agent to write a design document and issue files for a two-player creature battle game. The other seven were the same prompt repeated: take the next unfinished issue, implement it, test it in the browser, mark it done.
| Issues committed | 9 of 9 |
| Agent time | about 70 min |
| Per issue | 4 to 14 min |
| Cost reported by the CLI (covered by the subscription) | $32.82 |
| Tokens, mostly cache reads | about 26.8M |
It also got things wrong. Commit titles came from issue titles, so most of them read "Implement issue (copy) (copy)". One run was cut off mid-stream and left a log with no metadata. One issue reported $6.89 next to a couple of hundred tokens, which means the metrics only capture part of a resumed session. All three are on the list for the next version, together with worktree isolation and retries.
What changed for my team
In late 2025 I added an LLM step to our GitLab CI at Rogii. On every merge it reads the diff, posts a QA summary to the Jira ticket and adds a changelog entry in Confluence. The first version posted duplicate comments whenever CI retried a job, so it now drops identical requests that arrive within a minute.
By the summer of 2026 the whole frontend team used agents every day. In an August retro we saw that we were closing noticeably more work and also shipping more bugs, which QA then had to catch. We kept the higher pace and put the effort into checks instead: end-to-end tests for the key scenarios, and the review plugin above.
Tests written by agents have their own failure mode: they can pass whether the code is right or not. In September I went through our tree tests, fixed the ones that could not fail, and checked each fix against a deliberately broken copy of the source (details).
Dark Factory is a private repository for now. I'm glad to walk through it on a call.