Type-safe API
- End-to-end request types
- Typed API responses
- Compile-time error checks
Cursor, T3 Code, Claude Code, Codex, CopilotSame AI.
Same AI.
Suddenly senior.
Your agent reads the conventions before it writes, then builds the way a senior team would. When it drifts, lint and the compiler catch it in seconds.
.claude/rules
your agent reads these first
the difference
Same model. Better upbringing.
01
The conventions are written
How this codebase handles errors, where features live, what gets tested: 40+ rules ship in the repo, covering all six apps.
02
The agent reads them first
Cursor, Claude Code, Codex and Copilot load the rules before writing, so the first draft matches the house style.
03
Gates catch the rest
Anything that drifts fails oxlint or pnpm typecheck in seconds, and the agent corrects itself.
without rules
"Don't put the logic in the route handler. And no try/catch..." Twice a day, forever.
with rules
You never have that conversation. It was already in the file.
40+rules shippedthe team's conventions
1sttry is rightno correcting twice a day
2gates on driftlint and the compiler
One sentence in
You describe it. The agent builds all of it.
Real captures, not mockups. Billing installs finished from the Stripe pack, and the admin panel updates with it. Your agent never has to invent webhook retry logic, so there is nothing for it to silently get wrong.
you
Add billing with plans and a checkout.
Done. Typecheck clean.
Your app: shippedlocalhost:4200/billing
Admin: updated toolocalhost:4100
you
Add billing with plans and a checkout.
Done. Typecheck clean.
Your app: shippedlocalhost:4200/billing
Admin: updated toolocalhost:4100
You don't have to be technical
You bring the direction. It brings the engineering.
The toolkit makes the agent the senior engineer on your team, so your focus goes where it should: the product, the direction, and what you need to succeed.
Describe the product, not the architecture
Say what should exist, in plain language. The agent already knows how this codebase does screens, data, and permissions.
The senior habits come pre-installed
25 rules and skills ship with the project and the agent reads them before writing, so it works like someone who has been on the team for years.
Wrong turns are caught for you, in seconds
Lint and the compiler check every change automatically. A bad guess cannot ship, whether or not you would have spotted it yourself.
Your attention stays on the business
Pricing, users, the next feature, the direction. The technical part is the agent's job, and this is the equipment it does it with.
one prompt's journey
- 1Agent reads the rules
.claude/rules/
backend-errors.md
testing-workflow.md
theming.md
Shipped with the project, in the folder each editor already looks in.
- 2Builds like the team
- +features/billing/house style
- +routes/billing.tshouse style
- +billing.test.tshouse style
Files land where the team puts them, tests included.
- 3Gates catch the rest
- ✓oxlint2s
- ✓typecheck9s
- ✓testsgreen
Anything that drifts fails in seconds, and the agent fixes it.
3x
Fewer retries before a change lands
The agent reads the conventions instead of guessing at them.
blank repo3 trieswith the toolkit1 try25
Rules and skills it studies before writing
Rules and lint live in the public template, the skills land fresh from skills.sh at create time.
13 rules8 skills4 lint0
Conventions left to argue about in review
Breaking one fails the build in seconds, so drift never ships.
typecheck9soxlint2sconventionsenforced
The conventions are written.
Your agent reads them first.
✓ lint✓ typecheck✓ tests
Built so your agent acts like a senior developer
One ruleset, read by every tool. Feedback lands in seconds, so a retry costs your agent seconds instead of costing you a review.
One ruleset
Works with your AI editors
Pick every editor your team uses. The rules convert at create time, one set each.
Cursor
.cursor/rules
T3 Code
AGENTS.md
Claude Code
.claude/rules
Copilot
.github/instructions
Rust-native
The loop is native
Save, and the answer is back before the agent moves on.
~10x
faster typecheck, reported by the TypeScript team
- oxlint 1.61Rust
- oxfmt 0.46Rust
- Vite 8.0.10Rolldown
- TypeScript 7native
The equipment
What the agent works with.
Types that catch wrong guesses, tests that gate every change, and rules the agent reads before it writes.
Strict types
- Zod route validation
- Typed forms
- Strict TypeScript
Automatic SDK
- Generated from API routes
- Typed frontend client
- Catch breaking API changes
MCP server
- Search feature packs
- Review install plans
- Install from your editor
AI-ready code
- Feature-based structure
- Small, focused files
- Works with your AI editor
Agent instructions
- 13 coding rules
- 8 agent skills
- 4 custom lint rules
Tests & CI
- Unit & integration tests
- Nx-cached CI
- Pre-commit checks
Feature isolation
- One folder per feature
- UI, API & schema together
- Shared types across apps
Feature packs to grow with
Every pack ships real source code: frontend, backend, and admin surfaces where the feature needs them. Add them when you need them, one command each.
FeatureProjectsOrg-scoped projects with members, favorites, icons, and a navbar switcher.Project CRUDMembers & rolesFeatureTeamsTeam workspaces with members, roles, icons, and email invitations on top of your starter.Team workspacesMember rolesFeatureAI ChatStreaming conversations, voice, and image generation with reusable, feature-owned tools.Streaming conversationsVoice and imagesFeatureNewsletterNewsletters end to end: a hosted archive, signup surfaces for web and mobile, a minimal block studio with a full custom-HTML mode, scheduling, and open/click analytics built for sponsor reports.Block email studioPublic signup + unsubscribe
Questions, answered
Yes. Everything lands as plain source in your repository: frontend, backend, admin, database schema. There is no runtime dependency on us and nothing phones home.
Your agent already knows this codebase.
Scaffold a project, pick your editor, and the rules land where that tool looks for them.
13 rules / 4 lint rules / 8 skills