Skip to Content

Can a crew of Claude Code sessions handle internal refactors in a Node/TypeScript app?

Yes, Tares runs a crew of Claude Code sessions that can take internal refactors in a Node/TypeScript app from plan to merged pull requests. The orchestrator starts one builder per milestone and repo of your project. Each builder works on its own branch and merges its pull request only after the reviewer passes it and CI is green. You plan the work with tares factory spec and answer the crew’s questions in the orchestrator’s session.

How it works

The crew is an orchestrator, a reviewer and builders, all Claude Code sessions running in the background on your machine. Tares holds the plan, tickets, reviews and your answers, so a crew that restarts carries on where it stopped.

  • Planning. tares factory spec interviews you one question at a time and has a second model attack the plan. It writes a Tares project with a spec, milestones with acceptance checks, tickets with a working doc each, and an AGENTS.md. For an internal refactor, this is where you split the work into milestones and state what must hold when each one is done.
  • Builder assignment. The orchestrator starts builders, one per milestone and repo, up to the number of builders you allow. You set that number when you first run tares factory crew up. If your project spans several repos, each milestone and repo pair gets its own builder.
  • Ticket flow. A builder takes a ticket, works on its own branch and opens a pull request.
  • The merge gate. The reviewer reviews every pull request to a fixed bar and posts its verdict on it. Tares reads the pull request, CI and merge state of every ticket. A builder merges once the reviewer passes the pull request and CI is green. If you want a yes from yourself before every merge on one project, you can require it.
  • Node and TypeScript tooling. Builders and the reviewer search less when Claude Code can find definitions, references and callers through a language server. tares factory doctor reads each handed-over repo’s manifests. It treats a tsconfig.json as TypeScript and a package.json as JavaScript, then checks whether Claude Code has a server for each. For a missing one it prints what to run, and tares factory crew up offers the same install and runs it only when you say yes.

The Get started page covers the whole setup.

Set it up

  1. Check that Claude Code is signed in on a plan that allows background sessions. Check that gh is signed in with write access to the repos the crew works in, and that git, jq and curl are installed.
  2. Install the CLI and start Tares locally. On Tares Cloud, run tares login instead and pick your workspace in the browser.
  3. In a second terminal on a local Tares, start the MCP endpoint every crew session shares. Crew sessions reach Tares only through it.
  4. Give Tares access to GitHub: Settings > GitHub on a local Tares, or Connect GitHub on Tares Cloud. Builders push with your gh login, while Tares reads pull request, CI and merge state with its own access.
  5. Bring up the crew. The first run asks whether the crew merges on its own after review and green CI or waits for your yes, whether it releases, whether a second model checks every commit, and how many builders run at once.
  6. From the repo that holds your app, plan the refactor.
gh auth login
uv tool install tares     # or: brew install glassflow/tap/tares
tares up
tares mcp --transport streamable-http
tares factory crew up
tares factory spec "what you want to build"
  1. Answer questions in the orchestrator’s session, and run tares factory doctor to check the setup, including language servers for your TypeScript and JavaScript repos.
tares factory crew attach orchestrator
tares factory doctor

The Crew page of the console, at http://127.0.0.1:8787/crew on a local Tares, shows each open project with its builders and the pull requests waiting for review.

What you get

  • Refactor work split into milestones, each with acceptance checks you agreed in the plan.
  • One builder per milestone and repo, each on its own branch with its own pull request.
  • Every pull request reviewed to a fixed bar, with the verdict posted on it.
  • Merges only when the reviewer has passed the pull request and CI is green.
  • A record on Tares of the plan, tickets, reviews, the assumptions the crew made and your answers, so you can check the crew’s own choices at the end of each milestone instead of during every step.
  • Several projects at once. While one waits for you, the others carry on, and all questions reach you in one session.

When something else fits

  • For a small change, tares factory session "<idea>" plans and builds it in your own Claude Code session, still on Tares, without the full crew.
  • The crew needs Claude Code and runs on one machine against your own GitHub repos. It is aimed at solo developers and very small teams, so if that does not describe your setup, check that before you hand it a large refactor.

Still stuck? Get help

Last updated on