Prisma 7.10 is safe to commit the generated/prisma client?

[DarkKingpro10]

In the last versions of Prisma it was recommended to not commit the generated code of Prisma Client, but in the new version of Prisma Next V8 and Prisma 7.10 it is safe?
I understand that there is a Discussions where it was recommended to not commit the generated/prisma.

But now in 2026 it is Rust free so why is it not recommended?

[paramjeetn]

The recommendation still stands: you should NOT commit the generated/prisma client folder to git, even with the modern TypeScript-only / Rust-free query engine architecture.

Why you should keep it in .gitignore and generate in CI/CD:

1. Schema Synchronization:
   If a developer alters schema.prisma or pulls a branch without committing the freshly generated files, your committed client becomes out-of-sync with the schema, leading to confusing runtime typing mismatches.

2. Repository Size & Noise:
   Generated client files can contain thousands of lines of verbose D.TS type definitions and boilerplate. Committing them creates massive git diff noise on every minor schema tweak or version upgrade.

3. Deterministic CI/CD Pipeline:
   The official and idiomatic practice is to run prisma generate in your postinstall script (or CI build step):

// package.json
{
  "scripts": {
    "postinstall": "prisma generate",
    "build": "next build"
  }
}

This ensures every machine (local dev, Docker containers, Vercel/Render deployments) generates the exact client matching the installed @prisma/client version on the fly.

[Pleo2]

The Rust-free architecture changes what can be generated, but it does not by itself change the source-control recommendation.

Prisma's current generator reference still explicitly says to exclude the generated directory from version control. The main reason is that the generated output may include a platform-specific query engine unless you use engineType = "client". Prisma's v7 generation guide also recommends regenerating after schema or generator changes, commonly in postinstall or before the production build:

• https://www.prisma.io/docs/orm/prisma-schema/overview/generators#prisma-client
• https://www.prisma.io/docs/orm/v7/prisma-client/setup-and-configuration/generating-prisma-client#when-to-run-generate

For a normal application on Prisma 7.10, I would therefore keep this committed:

• schema.prisma
• migrations
• prisma.config.ts
• the package-manager lockfile

and keep generated/prisma ignored, with prisma generate in CI/build.

If you explicitly use engineType = "client", the Rust-binary portability concern disappears, so committing the output can be technically safe when a deployment environment cannot run generation. It is still a deliberate trade-off: larger/noisier diffs and a risk of the generated client drifting from the schema or installed Prisma version. In other words, Rust-free makes committing more portable; it does not make it the recommended default workflow.

[kingofdead6]

I think the key distinction is that Rust-free does not automatically mean that the generated client should be committed.

With Prisma 7, if you're using the default setup, I'd still keep generated/prisma out of Git and run prisma generate during your install/build process. That keeps the generated client tied to the exact Prisma version and schema in the project.

However, if you're explicitly using:

generator client {
  provider   = "prisma-client"
  output     = "../generated/prisma"
  engineType = "client"
}

then the generated client no longer depends on the Rust query engine binary. In that case, committing the generated output can be technically viable, especially if your deployment environment makes running prisma generate difficult.

So I'd separate the two questions:

• Is it safe to commit it? It can be, depending on the generator/engine configuration.
• Is it recommended as the default workflow? Generally no — I'd still generate it during CI/build and commit the schema, migrations, config, and lockfile instead.

The Rust-free architecture mainly removes the platform-specific Rust engine concern; it doesn't remove the maintenance problem of keeping generated code synchronized with the schema and installed Prisma version.

[BLCCoreStudio]

It's safe in the sense that Prisma 7 generates plain TypeScript, but the current Prisma docs still recommend keeping the generated client out of git.

"prisma init" also adds "/generated/prisma" to ".gitignore".

So I'd still treat it as a build artifact and run "prisma generate" during install/build rather than commit it.

[jhmartins1]

I recently dealt with this while deploying a Prisma 7 project in Docker, and I would still avoid committing generated/prisma by default.

What worked well for me was generating the client as part of the Docker/build process:

COPY package.json bun.lock ./
RUN bun install

COPY prisma ./prisma
RUN bunx prisma generate

COPY . .

I keep the schema, migrations, prisma.config.ts and lockfile in Git, while the generated client stays ignored.

The important distinction IMO is that removing the Rust engine dependency makes the generated output more portable, but it doesn't really turn generated code into source code that needs to be versioned.

Generating it during the build also guarantees that the client matches the Prisma version and schema used by that deployment.

I would only consider committing it if the deployment environment specifically cannot run prisma generate. Otherwise, generating it in CI/Docker keeps the repository cleaner and avoids the generated client getting out of sync.

[sakshyambanjade]

Yes, it’s technically safe to commit the generated Prisma Client in Prisma 7.10, but I still wouldn’t recommend it for a normal app.

Rust-free mainly removes the platform-specific binary concern; it doesn’t remove the risk of generated code getting out of sync with your schema or Prisma version.

Better approach:

• commit schema.prisma, migrations, config, and lockfile
• ignore generated/prisma
• run prisma generate during install/build

So: safe to commit, but better treated as generated build output.

[rsheth8]

Short answer: yes, committing the generated client is now the recommended default in Prisma 6+ / V8.

Here is why the guidance changed:

• In Prisma v4/v5 the generated client was large, contained platform-specific binaries, and was regenerated on every prisma generate, so committing it created noisy diffs and bloated repos.
• Starting with Prisma 6 (and formalized in V8), the generator switched to a TypeScript-first output without bundled native binaries. The generated files are now small, stable, and deterministic — they only change when your schema.prisma changes.

Practical checklist for Prisma 7.10

1. Set output in your generator if you want it outside node_modules:

generator client {
  provider = "prisma-client-js"
  output   = "./generated/prisma"
}

2. Commit the output folder.
3. Remove prisma generate from your CI install step — it is no longer needed if you commit the output.
4. Keep prisma generate in your local postinstall script so new contributors get it automatically the first time.

If you are still on the default node_modules/.prisma/client output, you cannot commit it (it is gitignored by default). Moving to an explicit output path is what unlocks safe committing.