Skip to Content

How do I write a spec a Claude Code crew can build bug fixes from in a Python backend?

Tares writes the spec with you: run tares factory spec in your Python backend’s repo and answer the /tares:spec interview. It asks one question at a time, has a second model attack the plan, and writes the result into a Tares project. You get a spec, milestones with acceptance checks, tickets with a working doc each, and an AGENTS.md. Say yes at the end and the crew builds the bug fixes into pull requests merged on main.

How it works

You do not write the spec by hand. /tares:spec runs inside Claude Code and turns your one-line idea into a plan the crew can execute.

  • The interview. It asks you one question at a time. Your answers become the spec, so describe the bugs and your Python service in your own words.
  • The attack. A second model attacks the plan before it is final, so weak points surface while the plan is still cheap to change.
  • What lands in Tares. The plan is written into a Tares project as a spec, milestones with acceptance checks, tickets with a working doc each, and an AGENTS.md.
  • The hand-over. It ends by asking whether to hand the project to the crew. If you say yes, the orchestrator picks it up.

The crew is a set of Claude Code sessions on your machine: an orchestrator, a reviewer and builders. Builders are started per milestone and repo. Each takes a ticket, works on its own branch, opens a pull request, and merges it once the reviewer passes it and CI is green. Tares keeps the plan, the tickets, the reviews and your answers, so a crew that restarts carries on where it stopped. The Get started page covers the whole factory.

Set it up

Follow these steps in order. Steps marked local apply to a local Tares, and the one marked cloud applies to Tares Cloud.

  1. Check that Claude Code is signed in on a plan that allows background sessions. Sign in to gh with write access to the repos the crew works in. Make sure git, jq and curl are installed.
  2. Install the CLI.
  3. Local: start Tares with tares up, then in a second terminal start the MCP endpoint every crew session shares. Cloud: run tares login instead, and pick your workspace in the browser. There is no MCP endpoint to start on Tares Cloud.
  4. Give Tares access to GitHub, so it can read the pull request, CI and merge state of every ticket. On a local Tares, add a GitHub token or App under Settings > GitHub. On Tares Cloud, choose Connect GitHub in your workspace settings.
  5. Bring up the crew. The first run asks how far the crew may go, such as merging on its own after review and green CI or waiting for your yes, and how many builders run at once.
  6. Plan the project from the Python backend’s repo, or a folder that holds its repos.
  7. Answer the interview, one question at a time, and say yes when it asks whether to hand the project to the crew.
gh auth login uv tool install tares # or: brew install glassflow/tap/tares # local Tares tares up tares mcp --transport streamable-http # in a second terminal # Tares Cloud instead of the two lines above tares login # after giving Tares access to GitHub tares factory crew up tares factory spec "fix the open bugs in our Python backend"

Write the idea so the interview starts from something concrete. Name the service, and say which bugs you want fixed and what correct behavior looks like. The interview then asks about whatever is still open.

If your bugs already live as GitHub issues, say so when you run /tares:spec: tell it the tickets should live in GitHub Issues and name the repo. Claude creates the issues with gh and links them, and Tares reads them about once a minute. For that, sign in with gh auth login --scopes repo and add a GitHub credential in Settings > GitHub that can read the repo’s issues.

After the hand-over, run tares factory crew attach orchestrator to answer the crew’s questions. They reach you one at a time, each with a recommendation. Run tares factory doctor at any point to check everything the crew needs.

What you get

  • A Tares project with a spec written from your own answers and tested by a second model before any code is written.
  • Milestones with acceptance checks, so each bug-fix milestone has a stated bar for done.
  • Tickets with a working doc each, so a builder picks up a ticket with its context attached.
  • An AGENTS.md that every session on the project shares.
  • Pull requests that the reviewer holds to a fixed bar and that merge on main only after the reviewer passes them and CI is green. If you prefer, a single project can wait for your yes before every merge.
  • A record on Tares of the plan, reviews, assumptions the crew made and your answers. The Crew page shows each project’s progress, its builders and the pull requests waiting for review.

When something else fits

  • For a small fix that does not need a crew, run tares factory session "your idea". It plans a short spec and ticket list on Tares and builds it in your own Claude Code session. If the plan turns out big, it offers the full spec and the hand-over to the crew instead.
  • If you keep tickets in Linear, link a Linear project to the Tares project. Tares only reads the tickets, and your sessions change them in Linear.

Still stuck? Get help

Last updated on