--- title: "Kirimase Review 2026: CLI-Generated Next.js SaaS" description: "Is Kirimase the best CLI for scaffolding Next.js SaaS apps? We review its component generation, auth options, database support, and comparisons to alternatives." date: "2026-03-09" tier: 1 authors: ["team"] tags: ["kirimase", "saas-boilerplate", "next-js", "cli", "create-t3-app", "2026"] --- ## 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. ```bash # 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 ```bash # 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:** ```prisma 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):** ```typescript // 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:** ```typescript // 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: ```typescript 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: ```bash # 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): ```bash # 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](/guides/shipfast-review-2026) and other Next.js SaaS starters at [StarterPick](/).* *See our guide to [T3 Stack variations](/guides/best-t3-stack-variations-2026) for the broader T3 ecosystem.* *Browse all [free open-source SaaS boilerplates](/guides/best-open-source-saas-boilerplates-2026) at StarterPick.*