# Ship a feature end to end with a squad

> The ship-a-feature squad is a Tallos playbook that builds one feature end to end with the Leader divides the work template. A leader agent splits the objective into API, UI and tests, runs one member per part in its own worktree, checks every result, combines them into one branch and stops so you can accept or discard.

- Canonical: https://runtallos.com/squads/ship-a-feature
- Português: https://runtallos.com/pt/squads/entregar-uma-feature.md
- Updated: 2026-09-29
- Section: Squads

## Key facts

- Template: Leader divides the work
- Leader + 3 members: API, UI, tests
- Suggested limits: 5 rounds · 4 members at once
- Each member works in its own worktree
- Nothing merges without your approval

## When should you use the ship-a-feature squad?

Use it when a feature has parts that can be built at the same time without touching the same files: an API, a UI and the tests that prove they work together. The leader hands one part to each member and combines the results into one branch you review once.

- **Good fit:** a feature that touches an endpoint, a screen and an end-to-end test.
- **Poor fit:** a one-file fix. One agent in a [parallel workspace](https://runtallos.com/features/parallel-workspaces) is faster.
- **Poor fit:** an open problem with no obvious approach. Try [best of three](https://runtallos.com/squads/best-of-three) first.

## How do you set up the squad?

Open **Squads → New squad** and pick **Leader divides the work**. The template prefills three workers with a generic function. Rewrite each one to say exactly who owns what: the leader is told never to hand a member work outside its function.

| Role | Agent (example) | What it does |
| --- | --- | --- |
| Leader | Claude Code | Splits the objective, starts the members, checks each result, combines them and writes the final report. It does not write code. |
| Member 1: API | Codex | Builds the cancel endpoint and the Stripe webhook. |
| Member 2: UI | Gemini CLI | Builds the cancel dialog and the billing settings page. |
| Member 3: tests | OpenCode | Writes end-to-end tests for cancel → refund. |

_Agents are examples. Any agent connected in Tallos can take any role._

> **Agents and models are your call** — Each slot, leader or member, picks its own agent, model and effort level. When an agent's CLI accepts a model flag, Tallos applies your choice at launch; otherwise the agent uses its own settings. Mixing vendors is optional. Set agents up once in [Connections](https://runtallos.com/features/agent-connections).

## What objective should you paste?

Write the result you want, the boundaries and how the leader can tell it is done.

```text
Add Stripe subscription cancellation with proration.

Scope
- API: POST /subscriptions/:id/cancel cancels at period end and prorates the refund.
- Webhook: handle customer.subscription.deleted and mark the account as cancelled.
- UI: a Cancel dialog on the billing settings page that shows the refund before confirming.
- Tests: end-to-end cancel -> refund, plus the webhook path.

Constraints
- Use the existing Stripe client in src/billing/stripe.ts. No new dependencies.

Done when
- pnpm test and pnpm e2e pass.
- The final report lists every file touched and what I should check by hand.
```

**Leader instructions** are optional; the template prefills a sensible default. Add an order if it matters, such as "combine the API first, then the UI, then run the e2e suite."

## What limits should you set?

Keep the defaults: **5 rounds** and **4 members at once**. That leaves room for a fix-and-recheck loop without letting the squad wander.

| Setting | Recommended | Why |
| --- | --- | --- |
| Max rounds | 5 (default) | One round is plan → dispatch → review. The rest is buffer. |
| Max members at once | 4 (default) | Three parts in parallel plus one free slot for a restart. |
| Hard ceiling | 20 rounds · 12 members | Tallos refuses member starts past your limit; the leader must report when rounds run out. |


> Build this squad in Tallos: pick the template, paste the objective, start. → https://runtallos.com/signup

## How does the run go?

Here is one example run. The details are illustrative; your run depends on your code and your agents.

1. **The leader plans** — It splits the objective into API, UI and tests and starts three members, each in its own new child worktree so changes cannot collide.
2. **Members build in parallel** — Endpoint and webhook, dialog and settings page, e2e suite. Each member has a terminal you can open from the squad view.
3. **The leader checks each part** — In this example run, one e2e test fails: the refund is off by one day.
4. **Round 2: a targeted fix** — The leader sends the failure back to the API member only, then reruns the check.
5. **A question for you** — Proration is a product call, so the leader asks: to the day or to the second? The run shows **Needs your answer** until you reply.
6. **Combine and report** — With every check green, the leader combines the parts into one branch in its own worktree and files the report with `tallos squad report`.

The squad view tracks **Rounds**, **Started**, **Succeeded**, **Failed** and an **Estimated cost** when the models have a known price.

## What will the leader ask you?

The leader asks only when it is truly blocked, usually on a product decision. It runs `tallos squad ask`, the run switches to **Needs your answer**, and you pick an option or write your own.

- **Behavior:** "Prorate to the day or to the second?"
- **Conflicts:** "The API and the UI disagree on the error shape. Which one wins?"

Answer precisely: a vague answer usually costs a round.

## What do you get at the end?

You get a final report, results by worktree and a decision. Nothing touches your base branch until you act.

- **Final report:** what was done, the recommended worktree, open risks and what to verify by hand. In the example run: cancel at period end, prorated to the day, six new e2e tests passing.
- **Results by worktree:** the leader's combined branch plus each member's worktree, each with **View changes**. The one the report points to is marked **Recommended**.
- **Accept or Discard:** Accept turns the recommended row into **Open to create PR**. Discard keeps the worktrees, or also deletes the members' worktrees if you tick that option.

Review the combined diff like a teammate's PR. See [how to review AI-generated code](https://runtallos.com/learn/review-ai-generated-code).

## What variations work well?

- **Add a reviewer.** A fourth member with the function "Reviews the combined branch for security and data handling." For review-heavy work, start from [build and review](https://runtallos.com/squads/build-and-review) instead.
- **Split by package, not by file.** In a monorepo, write functions like "owns packages/api" and "owns apps/web" so no two members edit the same package.
- **Save it.** Click **Save as squad** and reuse the roster for the next feature. Only the objective changes.

## What are the common mistakes?

- **Vague member functions.** "Helps with the feature" gives the leader nothing to route on. Write the job: "builds the API endpoint and its migration."
- **Parts that overlap.** If two members edit the same file, combining turns into conflict resolution.
- **No done-when.** Without a test command, the leader has to guess when to stop.
- **Raising limits to fix a bad objective.** More rounds won't rescue an unclear goal. Stop, sharpen the objective, start again.

New to squads? Walk through [your first squad](https://runtallos.com/learn/your-first-squad), or read how [squads](https://runtallos.com/features/squads) work under the hood.

## Frequently asked questions

### Can the leader and the members use different AI agents?

Yes. Every slot picks its own agent, model and effort. A leader on one agent can supervise members on three others, or all four can run the same agent.

### Does the squad leader write code too?

No. The leader plans, dispatches, checks and combines; the members implement.

### What happens if two members need to edit the same file?

Each member works in its own worktree, so nothing collides while they build. Overlap shows up when the leader combines the branches, so split cleanly.

### Can I stop a squad in the middle of a run?

Yes. Stop squad ends the leader and its members, and every change already made stays in its worktree for you to inspect.

### Does Tallos merge the finished feature into main?

No. The leader is told never to merge, push or apply changes to the base branch. After you accept, you open the recommended worktree and create the pull request yourself.

### How is a squad different from three agents in three terminals?

Three terminals give you three outputs to stitch together by hand. A squad adds a leader that splits the work, checks each part, loops on failures and hands you one combined result with a report. See [one agent vs many](https://runtallos.com/compare/one-agent-vs-many).

---

**Run your agents in parallel with Tallos** — Claude Code, Codex, Gemini and 30+ agents — each in its own workspace, with squads, chat, terminals and review in one app. Uses the subscriptions you already have.

https://runtallos.com/signup (macOS 13+ · Windows 10+)