bdd-agents-handoff: How My Temporary Agent Team Gets Work Done
The skill name says it all: BDD to define how the product should behave, handoff to turn the discussion into documents someone can pick up, and a lead agent with a few sub-agents to get the work done.

In my last post I shared how I think about Agent Teams, and I briefly mentioned a skill called bdd-agents-handoff. This time I want to walk through what it actually is.
Last time I drew a flowchart that looked fairly complicated. That's because I layered my own habits on top of the core process.
The core of the skill is already in its name: BDD, agents, and handoff.
Let's take them one at a time.
01 | BDD: Define How the Product Should Behave First
BDD stands for Behavior-Driven Development.
"Behavior" here means: in a specific scenario, what the user does and what result the system should give.
The other common one is TDD, where the T stands for Test. The basic approach is: write the test, write the implementation, then refactor.
They work together. TDD doesn't ignore the frontend, and BDD isn't only about the UI. The point is to spell out user scenarios and expected behavior first, then use them to guide development and acceptance.
In my own workflow the difference is concrete. When I had agents work TDD-style, attention went mostly to code logic and whether tests passed. Now I also write into the acceptance criteria how the product should actually feel to use.
The most obvious difference: my process takes longer now.
I also ask the agent to actually run the product, walk through each scenario, and check whether the results are right and the experience is smooth.

I used TDD for a long time, but after burning a lot of tokens I've come to feel that models are very good at logic. They can string together something that sounds convincing even when it makes no sense.
Even at this level of intelligence, getting a UI and interaction experience that needs almost no polish in one shot is still hard.
As for Opus 5.5, I haven't gotten my hands on it yet; my account is still warming up. I'll talk about it once I've used it rather than speculate.
All of this pushed my workflow toward BDD first, covering both backend logic and frontend experience.
02 | Handoff: Turn the Discussion into a Document Someone Can Pick Up
Handoff is easier to understand. It's literally a handover.
You ask the agent to condense your conversation into a handover document with only the key points.
This step connects naturally to all kinds of document formats and skills: ones that write PRDs, development plans, script outlines, and so on.
The one I use is a skill called handoff.
After each discussion, the agent follows the skill and produces two things:
- A clean development handover document, including BDD acceptance scenarios and a test plan.
- An iteration plan that splits the work into small loops, each of which can be completed and accepted on its own.
That way, the agent taking over knows what to do, how to do it, and what "done" means.

03 | Agents: Hire a Few Temps to Get the Work Done
Finally, agents.
Once the BDD acceptance scenarios and development plan are ready, the current lead agent brings in a few sub-agents to do the work, then reviews their commits, reports bugs, resolves conflicts, and merges the results.
In my setup, the lead agent doesn't write implementation code. It assigns tasks and strictly checks the sub-agents' commits against the plan.
Put simply, inside this small loop the lead agent and sub-agents form a temporary team that gets my request done.
All I need to do is state what I want and confirm the plan.

04 | My Habit: New Task, New Session
Last, the personal habits I've built in.
I mentioned this in the earlier post: I like to open a new session for each new task.
But I often have several tasks I want to do at the same time.
For example, I built a tool called likeit to improve how I listen to music.
Yesterday I noticed the UI stutters after it has been idle for a long time. That kind of experience problem has to be fixed.
At the same time, I saw a really slick UI animation that I wanted to add.
So I open two agent sessions: one fixes the stutter, the other builds the animation.
That creates a new problem: the two lead agents, plus the sub-agents each of them calls in, can step on each other.
To reduce that risk, I have the lead agent check the working tree for uncommitted changes before starting, then use commit history and task records to figure out which task and which agent those changes belong to.
Once the boundaries are clear, it creates a new branch for its own task, so it doesn't accidentally change the other team's work.
One caveat: if both sessions are still working in the same directory, a new branch alone does not isolate their file changes.
To work in parallel, each team needs its own working directory, for example with Git worktree, so every team works in its own directory and branch. Conflicts get handled together at merge time.

So the process has gradually become this:
State the request → discuss and confirm the plan
Write the handover document → split into iterations
Confirm work boundaries → isolate working directories
Sub-agents execute → lead agent accepts
Feedback and fixes → merge the results
That's about it.
Nothing too hard. So far it works reasonably well, and I hope it helps.