Skip to content

Blog

The agent shipped a story while the developer slept

In a pilot, an agent implemented a complete user story overnight. When work no longer needs a person awake, sprint planning, team sizing and the developer's job have to be rethought.

Written by

Software Factory

Published: 11 March 2026 Updated: 2 min read

A developer was sleeping. The agent was shipping.

This isn’t a metaphor. It happened during an agentic engineering pilot at a large retailer. Welcome to async engineering.

The old model needs a developer awake

A developer picks up a story, works on it for 1 to 2 days, commits, gets a review, ships.

The entire value chain requires the developer to be awake, focused, and available. Every hour of output requires an hour of human attention.

What actually happened

A developer set up the context, defined the spec, and kicked off the agent. Then the developer went to sleep. The agent implemented the complete user story overnight.

Not a proof of concept, not a toy demo: a production story, in a real sprint, at a real company.

Old assumptions that no longer hold

The way teams plan rests on assumptions that break here:

  • Sprint planning assumed work happens during working hours.
  • Team sizing assumed one developer equals one unit of attention.
  • Velocity assumed human output per sprint.
  • “Availability” meant being online and typing.

What replaces them:

  • Work now happens in cycles, not shifts.
  • A developer’s value is in context engineering, not typing speed.
  • Sprint capacity decouples from human hours.
  • The agent doesn’t need coffee breaks, standup meetings, or focus time.

What a developer does while awake

If an agent can implement a story while you sleep, what should a developer do while awake?

The work that agents cannot do: defining the problem, engineering the context, validating the output, making architectural decisions, talking to users. That work decides whether the generated code is worth shipping.

The shift is when work happens

The real shift isn’t speed. It’s when work happens.

Async engineering means your team’s output is no longer bound by synchronized human availability. It’s bound by the quality of the context you feed the agents. The world of “everyone online at the same time, working on the same thing, during the same hours” is gone.

Are you planning sprints around human hours, or around agent cycles?

Further reading

  1. Every company will build its own software factory The question shifts from which editor a team uses to what its factory looks like. Four stages lead from autocomplete to a factory that improves itself, and no team can buy its factory off the shelf. 2 min readShort post
  2. Compounding engineering makes each feature ease the next one Most teams use AI to code faster. Compounding engineering adds a fourth step, codify, so that every feature makes the next one easier to build. 2 min readShort post
  3. Run retrospectives for your agents, not just your team Teams run retros to improve how humans work, but agent mistakes die with the session. Saving sessions, letting a retro agent mine them and turning failures into config rules makes the learning compound. 2 min readShort post

All 23 posts on Software Factory

ClientsClient work

Scaling needs named owners

Coding agents scale across teams when named people own the platform, the team practice, the guardrails, and the measurement. Rollout & scale is where that ownership is built and handed to internal owners, in your stack.

Training on this topic: Agentic Software Factory: Advanced Team Training
See Rollout & scale

Want to check one team first? The self-check: twelve yes or no questions, three minutes, instant result, no account. Take the self-check