# How to choose a project generator for your team

> Score eight project generators against your team's jobs, with each fact sourced, and see why template syntax alone picks a tool that cannot update a project.

Source: https://voxgig.com/howto/choose-a-project-generator-for-your-team

- Audience: platform-team
- Level: beginner
- Verified: 2026-11-22
- Published: 2026-11-22

## Short answer

List the jobs first: one-off scaffolding, repeated in-repo generation, and long-lived templates that must be re-applied. Record what each candidate does on prompts, tests, edits to existing files and its update path, with a source for each value, then weight those criteria per job and score. The update path decides the long-lived job, and a tie on template syntax decides nothing.

---
## You will need

Node 22 or later, and your list of project types. The scorer and its tests are JavaScript with no
dependency, and the sample installs `jostraca` only to measure it. Python and Go ran once, in
`record.sh`, and the page reads what that script committed.

## Approaches compared

| Approach | When it fits | What it costs you | When to pick something else |
| --- | --- | --- | --- |
| [Copier](https://copier.readthedocs.io/en/stable/updating/) | Templates that must be re-applied to many projects as they change | A Python runtime, Jinja templates, and a tagged template repository under git | Your team reads no Python and runs no Python tooling |
| [jostraca](https://github.com/jostraca/jostraca) | Generation inside a repository, from a model your own program holds | No CLI and no prompts, so you write and keep the program that drives it | People need to answer questions to start a project |
| [Nx generators](https://nx.dev/docs/kb/local-generators) | The repository is already an Nx workspace | Generators come in Nx plugins and run through `nx g`, so you adopt Nx first | Your projects live in separate repositories |
| [`openapi-python-client`](https://github.com/openapi-generators/openapi-python-client) | The project is a Python client for one OpenAPI document | Writes one kind of project, and `--overwrite` replaces your edits to its files | Anything that is not a generated client |
| [`swift-openapi-generator` package plugin](https://swiftpackageindex.com/apple/swift-openapi-generator/1.14.4/documentation/swift-openapi-generator/frequently-asked-questions) | Swift clients regenerated on every build, never committed | Generates code only, so the package around it still needs a scaffold | You must commit generated code, which takes its command plugin or CLI |
| [Yeoman](https://yeoman.io/authoring/file-system) | One-off scaffolding with prompts, by a Node team that reads EJS | No update path, and a rerun asks about every file it would overwrite | The template will change after projects exist |

Voxgig maintains jostraca, whose repository sits in its own GitHub organization. It is the only
tool on this page that Voxgig makes, and the weights the scorer uses are this page's own.

Copier updates a project from a changed template, but it needs Python and a template tagged in
git. Nx generators keep a workspace in step and work only inside Nx. jostraca merges into files that
exist, at the price of a program of yours to drive it. Yeoman starts projects and has no command to
update them.

## Write down what each tool does, with a source

`candidates.json` holds one entry per tool: its runtime, template language, prompts, test seam,
edits to existing files, update path and scope. Each value carries the sentence it rests on and
the page's address, or what was looked for and not found there. `record.sh` fetched every page
and found every quote, in `record/evidence.txt`. A value that comes from a plugin built for the
tool names it: pytest-copie and pytest-cookies for the two Python tools' tests, and
[cruft](https://cruft.github.io/cruft/) for Cookiecutter's update. jostraca's entry cites
`jostraca-facts.mjs`, which measures the installed package:

```bash
node jostraca-facts.mjs
```

```text output
jostraca 0.42.0 (shape 12.2.5)
  a bin entry in package.json: no
  mem: true  api.ts in the volume: 1, output folder on disk: no
  check() after a hand edit  drift: content api.ts
  merge with .jostraca/generated  hand edit kept: yes, generator change landed: yes
  merge after removing .jostraca  hand edit kept: no
  the same with conflict: 'fail'  run refused: yes, hand edit kept: yes
  .jostraca/.gitignore written  by default: yes, with control.version: no
```

It is a library, so a team writes a small Node or Go program to drive it. Its in-memory run and
`check()` let a test run it without touching the disk. Its update path is a three-way merge whose base sits in
`.jostraca/generated/`, which the default `.gitignore` drops. A fresh clone has no base, so the
merge overwrote the hand edit unless `conflict: 'fail'` was set or `control.version: true` had
committed the base. The scorer gives that path 2 points, one less than Copier's `copier update`.

The other seven entries were read from their documentation. Copier's update needs a
`.copier-answers.yml`, a template versioned with git tags, and a project under git.
[Projen](https://github.com/projen/projen) synthesizes its files whenever it runs, and says they
"should never be manually edited". Nx runs sync generators before tasks to keep files in step.

## Weight the criteria per job

A criterion matters for some jobs and not others. These are this page's weights, in `rubric.json`,
and `--rubric` takes a file of yours in their place:

```json title="rubric.json"
  "jobs": {
    "one-off scaffolding": { "prompts": 3, "templates": 2, "runtime": 2, "tests": 1, "scope": 1 },
    "repeated in-repo generation": { "editsExisting": 3, "tests": 2, "runtime": 2, "templates": 1, "scope": 1 },
    "long-lived templates": { "update": 4, "tests": 2, "runtime": 1, "templates": 1, "scope": 1 }
  },
```

`runtime`, `templates` and `scope` score against a team: the languages it runs, the template
languages it reads, and whether it works in an Nx workspace. The file holds three teams.

```bash
node score.mjs
```

```text output
team node
  one-off scaffolding          Yeoman 18, then Hygen 16 (tied)
  repeated in-repo generation  jostraca 18, then Nx generators 16
  long-lived templates         Cookiecutter, Copier, jostraca 18 (tied), then Nx generators 16
team node on Nx
  one-off scaffolding          Nx generators, Yeoman 18 (tied), then Hygen 16
  repeated in-repo generation  Nx generators, jostraca 18 (tied), then Hygen 14
  long-lived templates         Cookiecutter, Copier, Nx generators, jostraca 18 (tied), then Projen 14
team python
  one-off scaffolding          Cookiecutter, Copier 18 (tied), then Yeoman 10
  repeated in-repo generation  Cookiecutter, Copier, jostraca 12 (tied), then Nx generators 10
  long-lived templates         Cookiecutter, Copier 22 (tied), then jostraca 14
```

The same inputs under equal weights, every criterion worth one point in every job, give another
answer:

```bash
node score.mjs --rubric rubric-equal.json
```

```text output
team node
  one-off scaffolding          Nx generators, jostraca 12 (tied), then Hygen 10 (tied)
  repeated in-repo generation  Nx generators, jostraca 12 (tied), then Hygen 10 (tied)
  long-lived templates         Nx generators, jostraca 12 (tied), then Hygen 10 (tied)
team node on Nx
  one-off scaffolding          Nx generators 14, then jostraca 12
  repeated in-repo generation  Nx generators 14, then jostraca 12
  long-lived templates         Nx generators 14, then jostraca 12
team python
  one-off scaffolding          Cookiecutter, Copier 13 (tied), then Nx generators 8 (tied)
  repeated in-repo generation  Cookiecutter, Copier 13 (tied), then Nx generators 8 (tied)
  long-lived templates         Cookiecutter, Copier 13 (tied), then Nx generators 8 (tied)
```

Under the page's weights, jostraca leads one job for the Node team, by the two points that
`scope` gives it over Nx generators outside Nx. It ties Copier and Cookiecutter on the long-lived
job. Under equal weights the job stops mattering, and jostraca ties Nx generators for that team.
For a Python team, Copier and Cookiecutter tie under both sets, because cruft gives Cookiecutter an
update path.

A tie is a finding. Cookiecutter ties for in-repo generation with `editsExisting: none`, which
says the rubric needs a heavier weight on that criterion for that team.

## Score the generator your SDK already uses

For a team on `swift-openapi-generator`, the repeated in-repo job is taken. Its
[FAQ](https://swiftpackageindex.com/apple/swift-openapi-generator/1.14.4/documentation/swift-openapi-generator/frequently-asked-questions)
recommends the package plugin, so the build generates the code "on-demand, without the need to
check it into your git repository". It emits types such as `Client` inside a Swift package the
team already has, so the team still needs a scaffolder for one-off scaffolding. Swift was not
available here, so this was read and not run.

For a team on `openapi-python-client`, the tool is itself a one-off scaffolder for one project
type. `record.sh` ran 0.30.0 on `api.json`, edited the result and generated again:

```text title="record/openapi-python-client.txt"
openapi-python-client 0.30.0
first run wrote: .gitignore README.md pyproject.toml shelf_client/__init__.py shelf_client/api/__init__.py shelf_client/api/default/__init__.py shelf_client/api/default/get_book.py shelf_client/client.py shelf_client/errors.py shelf_client/models/__init__.py shelf_client/models/book.py shelf_client/py.typed shelf_client/types.py
second run, no flag: exit 1, client was not created
third run, --overwrite: README hand edit kept no, mine.py kept yes
```

Its update path is `--overwrite`: a file it writes is replaced, and a file it did not write stays.
Keep your own code in files of your own, and give the project around the client to a scaffolder
that scores well for Python.

## Check it worked

The suite feeds the scorer broken input, checks the rankings under both sets of weights, holds
jostraca's entry to what `measure()` sees in the installed package, and reads `record/evidence.txt`
for every quote.

```js title="score.test.mjs"
test('weighted on syntax alone, five tools tie and the first has no update path', () => {
  const rows = rank(tools, { templates: 1 }, rubric.teams.node, rubric)
  const leaders = rows.filter((r) => r.total === rows[0].total)
  assert.equal(leaders.length, 5)
  assert.equal(rows[0].tied, true)
  assert.equal(tools.find((t) => t.name === rows[0].name).update, 'none')
})
```

```bash
node --test score.test.mjs
```

```text output
1..9
# tests 9
# suites 0
# pass 9
# fail 0
# cancelled 0
# skipped 0
# todo 0
# duration_ms 231.845002
```

## When it goes wrong

The team chose on template syntax, and the long-lived job has no answer. Weight that job on
`templates` alone and look at the first row:

```bash
node score.mjs --syntax-only
```

```text output
team node, long-lived templates, weighted on template syntax alone
  1  Hygen          2  tied  update path: none
  2  Nx generators  2  tied  update path: sync
  3  Projen         2  tied  update path: resynth
  4  Yeoman         2  tied  update path: conflict-prompts
  5  jostraca       2  tied  update path: merge-needs-base
  6  Cookiecutter   0  tied  update path: update
  7  Copier         0  tied  update path: update
  8  Plop           0  tied  update path: none
```

Five tools tie, and [Hygen](https://github.com/jondot/hygen) leads on its name alone, with no
update path.[^1] Weight `update` for
that job, and read the `tied` column before you read the first row.

The scorer refuses a value it has no points for. A tool entered with `update: "maybe"` fails
`validate` and names the tool, so a typo cannot score as zero.

jostraca's merge overwrites a hand edit after a fresh clone. Commit the base with
`control.version: true`, or set `conflict: 'fail'` so the run stops instead.

## When not to do this

Do not score for a one-off. A team that scaffolds two projects a year can take the scaffolder its
framework ships and skip the rubric.

Do not adopt jostraca for scaffolding that people start by answering questions. It has no
prompts, and every project type needs a program of yours to drive it. Yeoman, Copier or
Cookiecutter ask the questions for you.

Skip Nx generators unless the code already lives in one Nx workspace. Outside it, the
workspace-native advantage turns into a tool your team has to adopt first.

Do not bring in a project generator at all when the project is one generated client.
`openapi-python-client` writes the whole Python project itself, and `swift-openapi-generator`'s
package plugin keeps generated Swift out of git, so either serves that job better than any
scaffolder scored here.

## Related how-tos

- [Migrate a Yeoman generator without losing its composition](/howto/migrate-a-yeoman-generator-to-a-newer-tool)

- [Choose a template engine for generating source code](/howto/choose-a-template-engine-for-generated-code)

- [Scaffold a Python API client project with Cookiecutter](/howto/scaffold-a-python-project-with-cookiecutter)

- [Set an overwrite policy for a regenerated SDK](/howto/set-an-overwrite-policy-for-regeneration)

- [Scaffold a service with a component-based generator](/howto/scaffold-a-service-with-a-component-generator)

## Last verified

Verified 2026-11-22 against Node 22.23.5 and jostraca 0.42.0 with `shape` 12.2.5.
`openapi-python-client` 0.30.0 and the Go module `github.com/jostraca/jostraca/go` v0.42.0 ran
once, in `record.sh`. `swift-openapi-generator` was read from its 1.14.4 documentation and not
run. The other seven tools were scored from the documentation pages `candidates.json` cites, read
on the same day.

[^1]: The tie-break is code-point order, which puts every capitalized name before `jostraca`,
spelled here as its npm package is named. Its [README](https://github.com/jostraca/jostraca)
capitalizes the name in prose. Code-point order is the same on every machine, which is the only
reason it decides a tie here.