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.
Don't put the logic in the route handler. Keep the handler thin.
You're absolutely right. Moved it into a module function.
And no try/catch. Throw a typed error so Sentry sees it.
Got it. Throwing ApplicationError with a code instead.
You never have this conversation. Both rules ship in rules.
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.
you
Add billing with plans and a checkout.
Done. Typecheck clean.
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
22 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.
3x
blank repo3 trieswith the toolkit1 tryFewer retries before a change lands
The agent reads the conventions instead of guessing at them.
22
13 rules5 skills4 lintRules and skills it studies before writing
All of them countable in the public core template.
0
typecheck9soxlint2sconventionsenforcedConventions left to argue about in review
Breaking one fails the build in seconds, so drift never ships.
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.
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
The loop is native
Save, and the answer is back before the agent moves on.
- oxlint 1.61Rust
- oxfmt 0.46Rust
- Vite 8.0.10Rolldown
- TypeScript 7native
What the agent works with.
Types that catch wrong guesses, tests that gate every change, and rules the agent reads before it writes.
Type-safe API calls
Typed end to end with HyperFetch and Hono. Change a route and the frontend stops compiling. You catch bugs while typing, not from a user report.
Strict types across the stack
Zod-validated routes, typed forms, strict TypeScript everywhere. If it compiles, it works.
SDK that writes itself
Backend routes become a typed frontend SDK automatically. Rename a field and the UI breaks at compile time, not in production.
MCP server
The installer doubles as an MCP server. Your agent searches packs, shows the plan, and writes the files without leaving the editor.
AI-friendly codebase
Tight conventions, focused features, short files. Cursor, Claude and Copilot stay accurate instead of hallucinating as your project grows.
AI agent rules and skills
13 rules, 5 skills, and 4 lint rules ship in the repo. Your agent reads them before writing and stops guessing at conventions.
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.
Questions, answered
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 / 5 skills