Explore, design, apply
When a change starts in your coding agent instead of a meeting, you take it through three steps: explore it, design it, then apply it. Each is a slash command you type in Claude Code (in Codex, the same names with a dollar sign, such as /retain-apply). Together they turn a half-formed idea into a build packet: a change to your code, kept in Retain, from the reason for it to the pull request that ships it.
All three need a checkout of the repository open in your agent, and the agent needs Retain connected (see Connect Claude Code or Codex). A chat that only has the Retain connector, such as claude.ai, can't run them: it says so and stops.
Explore: think it through
Type /retain:explore and say what you are weighing. The agent reads the code that the change touches and what your Retain knows about it: who asked for this, what was decided in a meeting, an earlier design of the same area. It draws diagrams where they help and sets out several directions instead of picking one.
You are asked what comes up from what you said, one or two questions at a time. There is no form and no required ending.
Explore writes nothing: no notes, no tasks, no packet. If you ask it to save the plan, it offers /retain:design instead. When the direction settles, it summarizes the problem, the approach and what is still open, and offers to write the design once. You can decline and keep only the clarity.
Design: confirm a direction
Type /retain:design, straight after exploring or as the first step. You decide the direction, and the agent asks you to confirm it:
- The direction. If the conversation hasn't settled one, the agent lays out the options with their tradeoffs and asks which way to go. It states your choice back in one sentence and writes nothing until you confirm it.
- The name. It proposes a short name made of lowercase words, such as build-claims, and checks that this repository doesn't already have one.
- A Thread. If the conversation drew on a Thread the change advances, it asks whether to link the packet to it. It never picks one for you.
- Other packets it builds on. It asks whether this change must land after another packet. See Dependencies and stacked pull requests.
The agent then writes the proposal and the design against your real code, checks each, and sends both to Retain together. If either fails its checks, nothing is sent, so an abandoned session leaves nothing behind. The packet appears in Retain as Ready to build, and the agent offers /retain:apply.
If the agent can't write to the folder where packets are kept, it tells you what access to add when you start it.
Apply: build it
Type /retain:apply with the packet's name, from any checkout of the repository. The agent pulls the packet, then works in this order:
- It checks the design against the code as it is now and lists any claim that no longer holds. If the design lists open questions, it asks you about each before building.
- It writes the requirements and the tasks, because only it can read your code, and sends them to Retain. The packet is now Planned.
- It builds on a branch of its own, ticking tasks off as each is finished and checked, and sending the ticked list back to Retain as it goes. The packet is Building, and the Work list shows the count.
- It opens a pull request when the build is ready for review and links it to the packet.
- When every task is checked, it offers to archive the packet, which is your call.
Add --review to stop after the requirements and tasks reach Retain, so you can read them in the app before anything is built. Running apply again builds it.
You are also asked when something needs a decision: an edit made in Retain while the agent was working, a build already underway elsewhere, or a dependency that isn't ready. Follow the build from the Build tab.
What ends up in Retain
- After design: the proposal and the design, and the packet's name, Thread and dependencies.
- After apply writes its half: the requirements and the tasks.
- During the build: the ticked tasks, the branch, a link to the agent's session and the pull requests.
- After archiving: a frozen record of what was built, with the commits and files it changed. It is a snapshot of this build, not a spec anyone keeps up to date.
Need help?
Can't find what you're looking for? Contact our support team for a quick reply.
Contact Support