TL;DR #
- At Daylight, Claude Code picks up tasks from a Slack channel, writes the fix, and opens a PR. mirrord gives the agent a preview environment wired into real services, real data, and real third-party integrations.
- The agent inspects its own change inside that mirrord-powered preview environment and confirms the work end to end before the PR reaches a human reviewer.
- Verification takes about 5 seconds per cycle, versus the 5+ minutes a traditional CI loop would take, so the agent (and the human supervisor) can act on the result immediately.
- The result: humans review PRs that have already been validated, not raw code from an agent that has never seen its own output.
The challenge: AI writes code faster than humans can verify #
Daylight’s developers already run their day-to-day workflow on mirrord, connecting straight into the shared pre-prod cluster from their laptops instead of maintaining per-developer cloud environments. The human feedback loop was already fast.
As agents started writing more of the code, that speed stopped being enough on its own. The new bottleneck wasn’t writing the code, it was knowing whether any of it actually worked.
“There’s so much code being written, and what do you do after that? If you don’t have the right setup, if you don’t have the right mechanisms in place after that code is written, you’re just in a pile of code that you can’t manage.”
— Itay Hilel, AI Automation Engineer
Without mirrord, the only way to verify a change would be to send it through the full CI loop: open a PR, wait for checks, wait for the image to push to ECR, wait for Argo to sync. That whole flow runs 5 minutes at minimum, and it would sit between every agent-written change and any signal on whether the change actually worked.
“If you need to wait 5 minutes till you can actually test something, you’ll wait until you have multiple changes that you want to test. You’ll double-think everything because you want to act fast. We’re running fast here.”
— Shira Lev, DevOps Engineer
The solution: Agents that see their own changes #
Daylight wired Claude Code into a Slack channel. A message in that channel describes a problem, Claude picks it up, writes a fix, and opens a PR. Then mirrord spins up a preview environment for the change and hands the agent a link into it. That preview environment is not a mock or a container in isolation, it is a live mirrord session wired into Daylight’s pre-prod cluster with real services, real data, and real third-party integrations. The agent tests its own change end to end inside that environment before flagging the PR as ready for human review.
“Code is done, PR is green, preview environment is live. We get a link and we put that into the mirrord extension. We can just see all of the changes. It can see all of its changes, and then we have more confidence going from PR to production.”
— Itay Hilel, AI Automation Engineer
“Checking a real change in Daylight in our dev environment would be around 5 seconds.”
— Shira Lev, DevOps Engineer
With verification that cheap, the agent iterates on its own work until the change actually behaves, instead of handing over a hopeful PR and moving on.
That’s what turns an AI agent from a code generator into something you can actually trust. Without a way to run its own changes, the agent hands off output that someone else has to verify: the human is left to do the work of finding out whether it actually runs. With mirrord, the agent has the same access to a live environment as any developer, so it can see its own changes work before the PR ever reaches a human.
The result: Supervised agents, confident releases #
The team’s posture toward agentic work shifted from “review every line carefully because nothing has been verified” to “review the PR knowing the agent has already confirmed it works.”
“The biggest change is giving us confidence, sending out agentic loops like Claude Code or Codex to do their work, and actually verifying that logically and visually the work is done.”
— Itay Hilel, AI Automation Engineer
5 minutes to 5 seconds #
Verifying a single agent-written change now takes about 5 seconds inside a mirrord-powered preview environment, versus the 5+ minutes a traditional CI loop would need. The agent iterates against real services and the human does the same on review, without either one waiting on CI between attempts.
Humans review validated work, not raw output #
PRs reach the team’s queue with a confirmation that the change executes against real services. Review time shifts from “does this even run” to “is this the right change.”
A workflow built for “more agents per developer” #
As the agent-to-developer ratio climbs, the supervision layer has to scale with it. Daylight’s mechanism is already in place: every agent-written change runs through a mirrord verification loop before it reaches a human.
“We’re going to use a lot more AI agents per developer. That means we need to be supervising that work. And mirrord is going to help us do that.”
— Itay Hilel, AI Automation Engineer
