RelayWork
Get started free →
FeaturesLearnSoloGlossaryMCP docsPricingChangelog
One person, several agents

Your agent has no memory.
You need somewhere to keep the reasoning.

Approval gates are usually sold as coordination — a way to stop colleagues surprising each other. Working alone, you get the other half of the value, and it is the half nobody talks about: a written, approved decision is the context your model does not carry between sessions.

The problem with working alone

It is not that you forget what you decided. It is that the model does, completely, every session — and you now produce far more code than you can hold in your head. A fortnight of agent-assisted work leaves you with a codebase you did not read line by line and no account of why any of it is shaped that way.

So the failure is not a bug. It is opening the project on a Tuesday, finding two functions that do nearly the same thing, and having no way to tell which one was the decision and which one was a detour. You ask the agent. It has no idea either. It cheerfully suggests a third.

A spec fixes this for the same reason a good commit message does, only at the level that matters: it records intent, and intent is the thing neither of you can reconstruct afterwards.

Five habits that make it worth it

  1. 01

    Write the requirements at the model, not for a reviewer

    Four lines is fine: the problem, what changes when it works, what you are not building, and any hard rule you will forget. You are not filing paperwork — you are writing the brief you will paste at an agent three times this week.

  2. 02

    Approve your own spec, deliberately

    It sounds like theatre and it is the highest-value thirty seconds in the loop: the moment you read back what you asked for before something builds it. Half the time you will change a line. That line is the whole return on the exercise.

  3. 03

    Let the agent explore before it plans

    Read the code, open a draft PR with stubs, then write the implementation notes from what is actually there. Plans written from imagination reference functions you renamed last month, and you will not notice until the third file.

  4. 04

    Anchor the decisions to lines

    Two or three permalinks pinned to a commit, each with one line on why. This is the artefact that pays you back: in six weeks it answers “why is it written this way?” without you reconstructing it from memory.

  5. 05

    Skip all of it for bugs and chores

    They are tasks. No documents, no gates, no ceremony. If being wrong is cheap, spend nothing on being right.

What the loop looks like with nobody else in it

The same twelve stages, with you as the approver. Requirements approved at v3, the implementation doc in draft at v4, code refs pinned to the commit you were working against, and a done checklist that will not let you call it finished without checking whether it worked.

you.relaywork.app/product/specs/AC-24
A spec in RelayWork with approved requirements, an implementation document in draft, the stage ladder at stage 4 of 12, and a done checklist in the right rail.
One workspace, one approver. Nothing about the gates requires a second person to exist.

Connect the agent, then stop briefing it

RelayWork speaks MCP, so Claude can read the approved spec, push a revision, attach permalinks for the code it just wrote, and ask for review. What it cannot do is approve — there is no approve tool, so the one judgement that is yours stays yours even when you are moving fast and would rather not be interrupted.

In practice this replaces the paragraph you re-type at the start of every session. The agent fetches the spec by reference, reads the open review notes, and picks up where the last session left off. Setup is one command — the MCP docs have it.

When you should not bother

A weekend project you intend to throw away does not need any of this — read nothing, ship it, enjoy yourself. The same goes for a script that will run twice. Ceremony belongs where being wrong is expensive, and nowhere else.

The threshold is roughly the moment something has a user who is not you, or the moment you stop being able to hold the whole thing in your head. Both arrive earlier than they used to, because agents made the code cheap and left the understanding exactly as expensive as it always was.

It scales when you are not alone any more

Nothing gets redesigned when the second engineer arrives. The specs they need in order to be useful already exist; the approver simply stops being you. Free while in beta, whole team, no seat caps.

Create your workspace