Kirimase Review 2026: CLI-Generated Next.js SaaS

TL;DR

Kirimase is a free CLI code generator that adds Rails-style scaffolding to the T3 Stack. The kirimase generate command creates a full CRUD vertical slice — Prisma model, tRPC procedures, and UI components — in one command. It's not a boilerplate you download; it's a code generator you run incrementally as your SaaS grows. Best for developers who know the T3 Stack and want faster feature scaffolding. Skip it if you need a complete SaaS product with landing page and billing UI pre-configured.

Rating: 3.5/5

What Kirimase Does

Kirimase extends the T3 Stack with an interactive CLI for generating production-ready code for specific features. Think rails generate scaffold for TypeScript full-stack apps.

# Initialize a new project
npx kirimase init

# Add optional integrations
npx kirimase add
# → Choose: stripe, resend, uploadthing, shadcn

# Generate a new resource (model + API + UI)
npx kirimase generate

Tech Stack

Kirimase generates code targeting the T3 Stack:

Framework:    Next.js 15 (App Router)
API Layer:    tRPC v11
Database:     Prisma (PostgreSQL, MySQL, SQLite) or Drizzle
Auth:         NextAuth v5 or Clerk
UI:           Tailwind CSS + shadcn/ui
Email:        Resend (optional add-on)
Payments:     Stripe (optional add-on)
File Upload:  UploadThing (optional add-on)

Getting Started

# Initialize (creates a new T3 project with Kirimase config)
npx kirimase init

# You'll be asked:
# ? Project name: my-saas
# ? Package manager: npm / pnpm / yarn
# ? TypeScript: Yes
# ? Database: Prisma (PostgreSQL)
# ? Authentication: NextAuth.js
# ? UI: shadcn/ui + Tailwind CSS

# Add integrations
npx kirimase add
# ? Packages to add: stripe, resend

# Generate your first resource
npx kirimase generate
# ? Model name: Project
# ? Fields: name (String), description (String?), status (String)
# ? Relations: User (many-to-one)
# ? Generate tRPC router: Yes
# ? Generate UI components: Yes

The Generate Command: Core Value

The generate command is why developers use Kirimase. Given a model name and fields, it generates the entire CRUD vertical slice:

1. Prisma Schema Addition:

model Project {
  id          String   @id @default(cuid())
  name        String
  description String?
  status      String   @default("active")
  userId      String
  createdAt   DateTime @default(now())
  updatedAt   DateTime @updatedAt
  user        User     @relation(fields: [userId], references: [id], onDelete: Cascade)
}

2. tRPC Router (complete CRUD):

// server/api/routers/project.ts
export const projectsRouter = router({
  getProjects: protectedProcedure.query(async ({ ctx }) => {
    return ctx.db.project.findMany({
      where: { userId: ctx.session.user.id },
      orderBy: { createdAt: 'desc' },
    });
  }),

  getProjectById: protectedProcedure
    .input(z.object({ id: z.string() }))
    .query(async ({ input, ctx }) => {
      return ctx.db.project.findFirst({
        where: { id: input.id, userId: ctx.session.user.id },
      });
    }),

  createProject: protectedProcedure
    .input(insertProjectSchema)
    .mutation(async ({ input, ctx }) => {
      return ctx.db.project.create({
        data: { ...input, userId: ctx.session.user.id },
      });
    }),

  updateProject: protectedProcedure
    .input(updateProjectSchema)
    .mutation(async ({ input, ctx }) => {
      const { id, ...data } = input;
      return ctx.db.project.update({ where: { id, userId: ctx.session.user.id }, data });
    }),

  deleteProject: protectedProcedure
    .input(z.object({ id: z.string() }))
    .mutation(async ({ input, ctx }) => {
      return ctx.db.project.delete({
        where: { id: input.id, userId: ctx.session.user.id },
      });
    }),
});

3. Zod Validation Schemas:

// lib/db/schema/projects.ts
export const insertProjectSchema = createInsertSchema(projects, {
  name: z.string().min(1).max(100),
  description: z.string().max(500).optional(),
  status: z.enum(['active', 'archived', 'draft']),
});

export const updateProjectSchema = insertProjectSchema.partial().required({ id: true });

4. UI Components (3 files):

• app/(app)/projects/page.tsx — List view with data table
• components/projects/project-form.tsx — Create/edit form with React Hook Form
• components/projects/project-card.tsx — Individual item card

This is 4-6 hours of repetitive CRUD code generated in under 30 seconds.

What's Included vs What's Missing

Feature	Included	Notes
T3 Stack foundation	✅	Next.js + tRPC + Prisma/Drizzle
shadcn/ui components	✅	Pre-configured
Authentication	✅	NextAuth or Clerk
CRUD scaffolding	✅	Core feature
Stripe integration	✅	Via kirimase add stripe
Email (Resend)	✅	Via kirimase add resend
File uploads	✅	Via kirimase add uploadthing
Landing page	❌	Not included
Subscription billing UI	❌	Stripe added but UI is minimal
Admin dashboard	❌	Not included
Multi-tenancy	❌	Not included

Kirimase vs Alternatives

	Kirimase	ShipFast	create-t3-app
Price	Free	$169	Free
Type	CLI generator	Pre-built starter	Stack template
Landing page	❌	✅	❌
Billing UI	Partial (integration only)	✅ Full	❌
Scaffold command	✅	❌	❌
Documentation	Good	Excellent	Excellent
Community	Growing	Small	Large
Best for	Scaffolding speed	Complete SaaS	Foundation

Where Kirimase Shines

Feature development speed: Once your project is initialized, adding a new resource takes under a minute with kirimase generate. Building the same feature manually (schema, router, validation, UI) takes 3-6 hours.

Consistency: Generated code follows the same patterns throughout the codebase. New team members can understand any generated feature because the structure is identical.

T3 Stack familiarity: If your team knows T3 Stack, Kirimase adds productivity without a new paradigm. The generated code is idiomatic T3.

Where Kirimase Falls Short

No complete SaaS kit: Kirimase doesn't include the marketing landing page, pricing page, billing portal, or onboarding flow that paid starters pre-build. You'll spend time building these.

Partial billing integration: kirimase add stripe adds the Stripe library and webhook handler, but doesn't generate subscription management UI or the billing portal.

Limited community: Compared to create-t3-app (25k stars), Kirimase's community is small. Fewer tutorials, fewer examples, fewer answers in Stack Overflow.

Cost-Benefit Analysis

Who saves time with Kirimase:

• A developer building a data-heavy SaaS with 10+ models (generates 20-40 hours of CRUD code)
• Teams that want consistent code patterns across a large application
• Developers who know T3 Stack well and want scaffolding without learning a new framework

Who is better served elsewhere:

• Founders who need a complete SaaS product quickly → ShipFast or Supastarter
• Teams new to TypeScript SaaS → create-t3-app for simpler setup
• Developers who need admin panel, landing page, and onboarding → paid starters

Final Verdict

Rating: 3.5/5

Kirimase delivers significant value for its specific use case: generating consistent, production-ready CRUD code for T3 Stack applications. The generate command alone justifies adding it to any T3 project. But it's not a complete SaaS boilerplate — you'll still need to build the marketing site, billing flows, and admin dashboard.

Use Kirimase if you know T3 Stack and want to skip repetitive CRUD boilerplate. Skip it if you need a complete SaaS product ready to deploy and sell.

---

Customizing Generated Code

Kirimase generates code you own — there's no dependency on Kirimase at runtime. After generation, the files are plain TypeScript that you modify directly. This is a meaningful advantage over SaaS boilerplates where customization means understanding an opinionated framework.

Typical customizations after kirimase generate:

Adding custom business logic to tRPC procedures: The generated getProjects query returns all projects for the user. To add filtering, sorting, or pagination:

getProjects: protectedProcedure
  .input(z.object({
    status: z.enum(['active', 'archived', 'draft']).optional(),
    search: z.string().optional(),
    page: z.number().int().positive().default(1),
    limit: z.number().int().min(1).max(100).default(20),
  }))
  .query(async ({ input, ctx }) => {
    const where: Prisma.ProjectWhereInput = {
      userId: ctx.session.user.id,
      ...(input.status && { status: input.status }),
      ...(input.search && {
        name: { contains: input.search, mode: 'insensitive' },
      }),
    };

    const [projects, total] = await Promise.all([
      ctx.db.project.findMany({
        where,
        orderBy: { updatedAt: 'desc' },
        skip: (input.page - 1) * input.limit,
        take: input.limit,
      }),
      ctx.db.project.count({ where }),
    ]);

    return { projects, total, pages: Math.ceil(total / input.limit) };
  }),

The generated code is a starting point, not a final implementation. Kirimase saves the tedious scaffolding; you add the actual business logic.

---

Kirimase vs Rails Generators: The Comparison

Rails' rails generate scaffold Post title:string body:text published:boolean is the model Kirimase draws from. The comparison is instructive:

What Rails generators do: Generate model, migration, controller, views (ERB), routes, and tests in one command. The generated code is production-ready for simple CRUD. Rails conventions mean the generated code integrates with the rest of the application automatically.

What Kirimase generates: Similar scope — model (Prisma schema), API layer (tRPC), validation (Zod), and UI (React components). The integration into the application is equally automatic.

Where Rails wins: Rails generators have decades of refinement. Edge cases (polymorphic associations, STI, complex validations) are handled by generator options. Kirimase is younger and handles more complex scenarios less gracefully.

Where Kirimase wins: TypeScript end-to-end type safety. The generated Zod schemas and tRPC procedures are typed throughout — a Rails scaffold gives you string-typed controller params that require manual Strong Parameters validation.

For TypeScript developers who've worked with Rails, Kirimase scratches the same itch with the benefits of the TypeScript ecosystem. The workflow (generate scaffold, customize, test) translates directly.

---

Integrating Kirimase into an Existing T3 Project

Kirimase doesn't require being used from project initialization. Adding it to an existing T3 project:

# Install Kirimase in your existing T3 project
npm install -g kirimase

# Initialize Kirimase config (reads your existing stack)
npx kirimase init
# Kirimase detects your existing Next.js, Prisma, and tRPC setup

# Start generating
npx kirimase generate

The init command reads your existing package.json and configuration files to detect which T3 Stack packages are installed. If you have Prisma + tRPC, Kirimase will generate code for that configuration. If you're using Drizzle, it generates Drizzle schemas instead.

The main constraint: Kirimase's generated code assumes shadcn/ui for UI components. If your existing project uses a different component library, you'll need to adapt the generated component files. This is usually straightforward — the tRPC procedures and Prisma schema additions are portable, and the UI files are the minority of generated code.

---

Workflow in Practice: Feature Development Cycle

A realistic workflow for a SaaS with Kirimase, adding a new feature (invoices):

# 1. Generate the invoice resource
npx kirimase generate
# Model: Invoice
# Fields: invoiceNumber (String), amount (Int), status (String), dueDate (DateTime?)
# Relations: Customer (many-to-one), User (many-to-one)

# 2. Run the Prisma migration
npx prisma migrate dev --name add-invoices

# 3. Review generated files
# ✓ Prisma schema additions
# ✓ server/api/routers/invoices.ts — complete CRUD tRPC procedures
# ✓ lib/db/schema/invoices.ts — Zod validation schemas
# ✓ app/(app)/invoices/page.tsx — list view
# ✓ components/invoices/invoice-form.tsx — create/edit form
# ✓ components/invoices/invoice-card.tsx — item card

# 4. Add generated router to tRPC root
# (Kirimase provides the instruction or auto-appends)

# 5. Customize the generated code:
# - Add PDF generation to the invoice router
# - Customize the invoice list to show totals by status
# - Add email sending on invoice creation

Total time from zero to a working invoice CRUD feature: 30-45 minutes, versus 3-6 hours building the same feature manually. The time savings compound across a feature-rich SaaS — a product with 15 resources saves roughly 60-90 hours with Kirimase.

---

What Kirimase Doesn't Generate: The Remaining Work

Understanding what Kirimase covers — and what it doesn't — prevents surprises when building toward launch.

Kirimase generates: Database schema entries, tRPC procedures (create/read/update/delete), Zod validation schemas, and basic list/form/card React components. This is the tedious, repetitive scaffolding that takes hours per resource.

What you still build:

• Marketing and landing pages — Kirimase is for the app, not the site
• Stripe subscription UI — kirimase add stripe adds the integration but not the billing portal page, plan comparison table, or upgrade flows
• Admin panel — there's no generated admin interface for viewing all users and subscriptions across accounts
• Onboarding flows — the generated CRUD is functional but not user-onboarding-ready
• Error states and loading skeletons — generated UI is functional, not polished

The honest scope of Kirimase: it handles the data layer and basic CRUD UI. The product experience layer — the onboarding, the billing flows, the empty states that help new users get value — is still your responsibility. For a SaaS with 10 resources, Kirimase saves the most time on the backend scaffolding and data tables; plan 2-4 additional hours per resource for the product experience on top. That ratio still represents a significant time saving over building everything from scratch. Kirimase's community has grown steadily, and the GitHub issues and discussions provide useful context when the generator produces schema patterns that need adjustment for specific data model requirements.

The boilerplate that works best is the one your team can productively extend. Documentation quality, community activity, and the clarity of the codebase architecture matter as much as the feature list when you're making the decision for a product you'll maintain for years.

---

Compare Kirimase with ShipFast and other Next.js SaaS starters at StarterPick.

See our guide to T3 Stack variations for the broader T3 ecosystem.

Browse all free open-source SaaS boilerplates at StarterPick.