The owl mascot holding a big wrench over its shoulder

Web platformJishu LabsCase study

Jishu Labs

An AI-augmented developer tools suite.

A suite of eight AI-augmented developer tools sharing one backend, one design language, and one sign-in.

Role
Principal AI Engineer (contract)
When
2024 to now
Team
Solo build
Read
About 4 min
The owl mascot holding a big wrench over its shoulder
  • SenseiAI Code Review & Comprehension
  • KeisanAI Project Estimation
  • KiokuDecision & Context Memory
  • KikuVoice & Audio Intelligence
  • KozoAI Database Schema Generator
  • ShivoAI Spec & PRD Generator
  • MichiLearning Paths & Roadmaps
  • JumbiAI Readiness Assessment
Shared UIcomponents, tokens, a11y
Shared backendSupabase, RLS, one sign-in
AI layerstreaming, structured output, evals

Overview

Overview

Jishu Labs is a suite of eight AI-augmented developer tools — code review, voice notes, schema design, learning paths, project estimation, spec generation, and more — sharing one backend, one design system, one authentication layer, and one LLM integration surface.

Built and shipped solo as a personal platform I dogfood every day: a codebase where new AI tools take days rather than weeks because the foundation is already solved.

The challenge

Building eight independent tools solo is a recipe for drowning in undifferentiated work.

Every tool needs auth, a database, a UI system, billing hooks, AI integration, deployments, and observability. Done eight times, that's eight months before any of them ship anything interesting. The real challenge was making each tool feel independent to users while sharing everything that should be shared under the hood.

  • Eight toolsbuilt and shipped solo
  • Shared foundationsauth, data, UI and AI
  • Independent feelfor every user

The solution

One shared backbone, thin apps on top.

Invested in one shared backbone — Supabase for auth and Postgres, a TypeScript component library for UI, design tokens for theming, and a set of reusable LLM integration primitives (streaming, structured outputs, prompt versioning, per-feature evals). Each tool is a thin Next.js app on top, deployed independently. A bug in one tool can't take down another, but they all share identity, data contracts, and the AI infrastructure.

Architecture

One shared backbone.

One shared backbone — auth, data, design, AI primitives — with each tool shipped as an independent Next.js app on top. Independent deploys, shared data, zero cross-tenant leakage.

Apps
  • 8 independent Next.js apps
  • Per-tool subdomain
  • Per-tool deploys
  • Shared design language
Shared UI
  • TypeScript component library
  • Design token system
  • Accessibility primitives
  • Dark mode + theming
Shared Backend
  • Supabase Postgres
  • Row Level Security
  • Edge functions
  • Shared auth + JWT
AI Layer
  • LLM streaming
  • Structured output
  • Prompt versioning
  • Per-feature evals
  • Embeddings + pgvector

One request, start to finish

  1. User signs in once on any tool
  2. Shared auth issues a JWT scoped to that identity
  3. Every tool validates the same JWT server-side
  4. Postgres RLS enforces tenant isolation on every query
  5. LLM features stream back to the UI with structured outputs

Decisions

Five calls and why I made them.

Call 01

Independent deploys, shared data

Tools fail differently and iterate at different speeds. Coupling their deploys would have turned every release into a coordination problem. Each tool ships on its own CI; only the data contract is shared.

Call 02

Row Level Security at Postgres, not the API

Multi-tenant data with AI in the loop is a leak waiting to happen. Enforcing tenant isolation at the database layer means a bug in any API route — or any future tool — can't cross user boundaries. Defense in depth, not trust in one layer.

Call 03

Component library is the real product

The leverage isn't any one tool — it's the shared library. Investing in primitives (theme, a11y, form patterns, loading states, empty states) made each new tool feel finished on day one instead of needing weeks of UI polish.

Call 04

One shared auth across all surfaces

Sign in once, use all. Separate auth per tool feels like enterprise IT circa 2010. One identity across the suite is the single biggest UX decision — and it's only possible because of the shared backend.

Call 05

LLM integration as reusable primitives

Streaming, structured output, prompt versioning, and per-feature evals show up in every AI feature. Codifying them once (with one wrapper, one eval harness, one prompt store) meant new AI features shipped in hours instead of weeks.

Reflections

What I took away.

The shared primitives are the real product

Every tool in Jishu Labs looks like its own app from the outside, but the part I spent the most time on is invisible: one auth flow, one Postgres with RLS, one component library, one LLM wrapper with streaming and structured output built in. When the eighth tool took me a weekend instead of a month, I realized the primitives were the actual product and the tools were just proof that they worked.

Dogfooding is a shortcut disguised as a hobby

I built these because I wanted to use them, not because I had a go-to-market plan. That let me skip the usual dance of user research and ship the version I personally needed on day one. Every tool that's survived is one I still open weekly. The ones I stopped opening got deleted. No better signal exists for a solo project.

Row Level Security is non-negotiable once AI is in the loop

Multi-tenant data and LLMs are a leak waiting to happen — one bad prompt and you're serving someone else's data as context. Enforcing tenant isolation at Postgres (not at the API layer) turned a category of terrifying bugs into an impossible class. Defense in depth isn't paranoid; it's cheaper than the alternative.

Outcomes

What shipped.

  • Tools8Live AI-augmented apps
  • Identity1Sign in once, use all
  • Backend1Shared infrastructure
  • Design1Unified design system

Stack

Technology

Frontend

  • Next.js
  • React
  • TypeScript
  • Tailwind CSS

Backend

  • Supabase
  • PostgreSQL
  • Edge Functions

AI

  • LLM-augmented features
  • Voice transcription
  • Embeddings

Infra

  • Netlify
  • Shared design tokens

Features

What it does

  • Multi-tenant Postgres schema with Row Level Security — one shared backend for 8 tools, zero data leakage between users
  • Shared TypeScript component library and design token system — new tools inherit identity, theming, and accessibility for free
  • Each tool deploys independently as its own Next.js app — fast iteration without breaking the others
  • LLM integration patterns: streaming responses, structured output, prompt versioning, and per-feature evals
  • Real-time voice pipeline (transcription + diarization) reused across multiple tools
  • Auth, billing, and user state shared via a single Supabase instance with edge functions for hot paths
  • CI/CD on Netlify with preview deploys per PR and automated migrations
  • Solo build: architecture, full-stack engineering, AI integration, design, and deployment

Keep reading

More case studies

Your project

Building something like this?

AI, voice, privacy constraints or a mobile app that can’t afford to break. Free 30-minute call, no pitch, clear next steps either way.

Email
Back to
All work