How do I write a spec a Claude Code crew can build framework migrations from in a Node/TypeScript app?

Tares turns a framework migration plan for your Node/TypeScript app into a spec by running /tares:spec, an interview that ends in a Tares project the crew builds. Start it with tares factory spec from the app’s repo. It asks one question at a time and has a second model attack the plan. It then writes the spec, milestones, tickets and an AGENTS.md to Tares.

How it works

You describe the migration once, and /tares:spec does the rest in Claude Code:

• Interview. It asks one question at a time, so you answer a single decision per turn instead of writing a long brief.
• Attack. A second model challenges the plan before anything is written down.
• Record. The result is written into a Tares project. It holds the spec, milestones with acceptance checks, tickets with a working doc each, and an AGENTS.md.
• Hand-over. The interview ends by asking whether to give 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. The orchestrator hands out work and is the only session you talk to. The reviewer reviews every pull request to a fixed bar. Builders are started one 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.

What you say in the interview is what the crew works from, so be specific about your migration. Useful things to state in your answers:

• The framework and version you are on, and the one you are moving to.
• Which parts of the app move first, so each milestone is one checkable step.
• What “done” means for each step, such as the build and tests passing in CI.
• Anything the crew must leave alone.

These are your inputs. Tares records whatever you and the interview settle on.

Set it up

1. Check that Claude Code is signed in, gh is signed in with write access to the app’s repo, and git, jq and curl are installed.
2. Install the CLI, then start Tares locally and the MCP endpoint every crew session shares. On Tares Cloud, run tares login instead and skip the local start.
3. Give Tares access to GitHub: Settings > GitHub on a local Tares, or Connect GitHub on Tares Cloud. Tares reads the pull request, CI and merge state of every ticket itself.
4. Bring up the crew.
5. Plan the migration from the repo, or from a folder that holds its repos.
6. Answer the interview, then say yes when it asks whether to hand the project to the crew.

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"

Put the migration in your own words where the command says what you want to build. Run tares up and tares mcp in separate terminals and leave them running. Use a third terminal for tares factory crew up and tares factory spec.

The spec step stops and tells you if the MCP endpoint does not answer, because the stations reach Tares only through it.

If you want the tickets in Linear or GitHub Issues instead of Tares, say so during /tares:spec. For GitHub Issues, name the repo. See Get started for both options.

After the hand-over, open the orchestrator to answer its questions. Run tares factory doctor any time to check what the crew needs:

tares factory crew attach orchestrator
tares factory doctor

Doctor reads tsconfig.json and package.json to find TypeScript and JavaScript in your repo. It reports whether Claude Code has a language server for each, and prints the fix for a missing one. Builders and the reviewer search less when a server can find definitions, references and callers. tares factory crew up offers the same install and runs it only when you say yes.

What you get

• A Tares project with the spec, milestones with acceptance checks, and tickets with a working doc each.
• An AGENTS.md that every crew session works from.
• A plan that a second model has already attacked, before a builder starts.
• Pull requests reviewed to a fixed bar and merged on main once CI is green.
• A record on Tares of the plan, the tickets and their stages, every review, the assumptions the crew made, and your answers. A crew that restarts carries on where it stopped.
• Questions that come to you one at a time in the orchestrator, each with a recommendation. The Crew page of the console shows the question waiting for you, the stations, each open project with its builders, and the pull requests waiting for review.

The crew writes down every choice it makes on its own, so you can check them at the end of each milestone.

When something else fits

• For a small migration, use tares factory session with your idea. It plans a short spec and ticket list on Tares, then builds in your own Claude Code session. If the plan turns out big, it offers the full spec and the crew hand-over instead.
• The factory is built for solo developers and very small teams already on Claude Code. It runs on one machine, on your own Claude Code login and your own GitHub repos.

Related