How-to › Model, configure and generate

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.

Audience
Platform team
Level
beginner
Topic
Generate code and projects
Verified

A year after you picked a scaffolder for its template syntax, the template has moved on and forty services still carry the CI file it wrote first. The tool can create a project but has no command that re-applies a changed template to one, so every service is patched by hand or left behind.

What you get

You will end up with a scored shortlist of project generators per job, where each score traces to a source or a run. This is for you if your team is about to standardize on one generator.

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

ApproachWhen it fitsWhat it costs youWhen to pick something else
CopierTemplates that must be re-applied to many projects as they changeA Python runtime, Jinja templates, and a tagged template repository under gitYour team reads no Python and runs no Python tooling
jostracaGeneration inside a repository, from a model your own program holdsNo CLI and no prompts, so you write and keep the program that drives itPeople need to answer questions to start a project
Nx generatorsThe repository is already an Nx workspaceGenerators come in Nx plugins and run through nx g, so you adopt Nx firstYour projects live in separate repositories
openapi-python-clientThe project is a Python client for one OpenAPI documentWrites one kind of project, and --overwrite replaces your edits to its filesAnything that is not a generated client
swift-openapi-generator package pluginSwift clients regenerated on every build, never committedGenerates code only, so the package around it still needs a scaffoldYou must commit generated code, which takes its command plugin or CLI
YeomanOne-off scaffolding with prompts, by a Node team that reads EJSNo update path, and a rerun asks about every file it would overwriteThe 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 for Cookiecutter’s update. jostraca’s entry cites jostraca-facts.mjs, which measures the installed package:

node jostraca-facts.mjs
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 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:

  "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.

node score.mjs
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:

node score.mjs --rubric rubric-equal.json
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 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:

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.

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')
})
node --test score.test.mjs
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:

node score.mjs --syntax-only
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 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.

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.

Footnotes

  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 capitalizes the name in prose. Code-point order is the same on every machine, which is the only reason it decides a tie here. ↩︎ Back to text

Read this page as markdown · All how-to guides

Generate the client instead of writing it#

Retries, timeouts, pagination and auth are the same problems in every client. Voxgig generates them from your OpenAPI description, in 23 languages, from one model.

Listen to Fireside, the Voxgig podcast

Since 2018, Richard Rodger has talked with developer advocates, event organizers, and the people who build developer-facing companies about the specifics of the work.