In August, Anthropic published the AI-Native SDLC playbook, a stage-by-stage account of how software gets planned, designed, built, tested, deployed, and maintained when agents do most of the typing. If you run an engineering team that uses coding agents, read it. It matches what we watch teams do every day.
The playbook runs on one idea: every stage ends by committing an artifact the next stage reads. An idea becomes intent.md. The intent becomes spec.md, the spec becomes plan.md, the plan becomes a diff with tests, the diff becomes a reviewed pull request, and a production incident becomes a new intent.md that re-enters the loop. Humans approve at the gates. Agents do the work between them. The artifacts are the audit trail.
It gets the core thing right. Agents made execution cheap, so the scarce thing is no longer code. It is decisions: what we meant, what we agreed to build, in what order, who reviewed it. The playbook turns each of those into a versioned document instead of a memory in someone's head. We built Coshell's Plan tab on the same conviction: specs and plans are documents in the workspace, approved in place, and a plan step can carry a verify command so a checked box is backed by a passing check instead of a claim. When we say the plan is the new source code, this is what we mean.
There is one thing the playbook never says.
Look at what the artifact chain does between people. An originator serializes what they know into intent.md and walks away. A product owner unpacks it, adds judgment, packs it again as spec.md. An engineer unpacks that and steers an agent into plan.md. The playbook is explicit about the model behind this: engineers run parallel agent sessions in separate worktrees, isolated by design, and handoffs happen through committed files rather than shared sessions.
Teams deep in agent work already have a word for this. A founder described his team's workflow to us this way: "We don't push code... it's like, just tell me what you did, and then they can resume. It's checkpointing. Instead of git commit, it's checkpointing your internal state." The unit of handoff changed from code to context, and every handoff means one person packaging memory and state into files so the next person can unpack them and work out what is done and what comes next.
The artifact chain is that checkpointing protocol, written down and given stage names. If your only shared medium is a git repository, committed markdown is the best checkpoint format there is. But a checkpoint exists because the other person was not in the room. So: what does the same lifecycle look like when they are?
That is what we build. Coshell is a multiplayer cloud coding environment. A drive is a persistent shared workspace, and several people can sit in the same live agent session, prompting the same agent, watching the same work happen. Run the playbook there and the artifacts survive. The packaging step between them disappears.
Intent still becomes a spec, and the spec still becomes a plan. In Coshell they are documents in the Plan tab, read and approved where the work happens, every referenced document one click away. The plan still gates the build, and verified steps still turn review from trust into evidence. But nobody writes "here is the memory, take it from here", because the session itself is shared: by the time your teammate in another timezone wakes up, they see what happened and continue from the session, not from your notes. Every prompt has a name on it, so the audit trail exists at the level that matters now, the conversation with the agent. Questions that would have become a meeting go to the room's chat, where the team and the assistant both see them.
The maintenance loop too. An incident lands in the room where the people and the agent already are. Diagnosis, discussion, and the new plan happen in one place, attributed, on the record, with nobody reconstructing state from a handoff document the next morning.
Anthropic is right about the lifecycle, and right that humans belong at the gates. The playbook describes that lifecycle as practiced by one engineer at a time, stitched together with checkpoints. Keep all of it. Then put the team in the same session, and it stops being a relay race. That is what Coshell is for.