Gridfin is an agent-native starter kit that turns an empty repository into an Application Skeleton: a ready-made architectural foundation for building with Claude Code. Specs, engineering rules, hooks, tests and quality gates are built in — instead of chaotic vibe coding.
If you have an idea and Claude Code but not years of engineering experience, Gridfin walks you through the process that engineering teams usually spend years assembling.
Free during the beta · starter prices after the beta
AI made development faster. But engineering experience still can't be generated. That is the gap Gridfin closes.
Stack, architecture, testing, security — dozens of decisions get made silently, without a second look.
Gridfin makes the engineering decisions up front: the invariant part is pre-decided and reused in every project.
Building was fast, debugging is endless; every new feature touches the previous ones.
Every feature goes through the same cycle: spec → code → tests → review. Old tests keep a new feature from silently breaking the previous ones.
Constraints you didn't know about start surfacing; the agent rewrites half the codebase over a small change.
The Application Skeleton locks the architecture from day one: the twentieth feature lands through the same process as the first.
What exactly it generated yesterday — nobody has read it.
Hooks and quality gates make review part of the process: a rule violation is stopped before the code is written, red status is visible before the merge.
One command — /gridfin — starts a guide agent. The pipeline shows the process and real artifacts at every step.
The agent interviews you, helps sharpen the idea — and says honestly if it doesn't fit this stack.
A PRD: the problem, the user, 3–5 key features and an explicit "not in v1" list. Specs come before any code.
The main result of the first steps: architecture, stack, tests and CI are already assembled — and tailored to you: project name, branding tokens, the data schema of your domain model.
/feature drives every feature through the spec → code → tests → review cycle.
Lint, tests, e2e and the build in one run — red is visible before the merge.
Deploy to Vercel by a step-by-step playbook. Every step is committed — a dropped session loses nothing.
Don't make the same decisions again — they are already made, proven and reused.
AI writes better code when it knows what it's building first.
Rules are enforced automatically — by hooks and gates, not wishes in a README.
Quality is a mandatory part of the process, not the last item before release.
An Application Skeleton is not a demo app and not a folder of templates — it is a pre-assembled architectural foundation for a product. Gridfin fixes the stack, the structure, the rules, the testing strategy and the quality gates before Claude Code starts writing features.
The stack, the layers, import boundaries and change rules are already chosen, so the agent doesn't rebuild the project from scratch on every feature.
Work starts with a PRD and feature specs: first it is clear what you are building, then the code appears.
Tests, lint, e2e and the build run as one quality gate, so a mistake becomes visible before the merge.
Skills and playbooks drive development through a repeatable cycle: idea → spec → code → tests → review → deploy.
Not a list of promises — a set of components in your own git repository.
A ready-made architectural foundation for your application — Next.js + TypeScript + Postgres. What's already inside:
Plus updates forever. It's a git repository that belongs to you. Not a subscription, not a service, not a rented site builder.
Step-by-step scenarios for deploys, analytics, pricing, compliance and other engineering tasks where session memory can't be trusted.
Agent workflows for onboarding, features, design, review, verification, deploys, updates and recording learnings.
Rules for architecture, frontend, testing, security, documentation and the git process the agent works by.
One run of lint, tests, e2e and build shows red before the merge, not after the release.
PRD, specs, ADRs, playbooks and rules keep the context between sessions, so the agent doesn't start the project over every day.
One kit — any number of projects: SaaS, landing pages, pet projects. Every launch is an hour with the agent, not a week of setup.
What you are literally buying: a repository, rules, specs, tests and a workflow.
gridfin/ src/ docs/ rules/ playbooks/ templates/ tests/ modules/ scripts/ .claude/skills/ CLAUDE.md lefthook.yml
src/
Your product grows here.
docs/playbooks/
Ready-made engineering processes.
CLAUDE.md
The rules the agent follows.
tests/
They check every change.
This is not SaaS: the code, the rules and the process stay with you and keep working even if Gridfin the product disappears.
The template is versioned; the /update command pulls new releases into your project without overwriting your code.
An idea outside its profile gets declined at step one, not after a week of work. No "fits everything" promises.
Gridfin is built with the same process that ships inside the product.
This landing page was built with Gridfin too.
Run /gridfin on a real idea and tell me where you stumbled — the box is yours forever, with all future updates, free.
After the beta — starter prices that will only go up: Gridfin Landing — $— · Gridfin App — $—
Plain Claude Code writes code but doesn't give you a stable engineering process. Without Gridfin, every session re-decides how to build the project; with Gridfin the agent works by specs, rules, hooks, tests and quality gates that can't be silently bypassed. The full story: why AI development needs engineering rules.
Boilerplates sell pre-assembled code that you customize. Gridfin is an agent-native starter kit: a thin skeleton plus a process that specs, builds and tests your product specifically. You don't strip down someone else's dashboard — you grow your own.
An Application Skeleton is the architectural foundation on which Claude Code builds your specific product. It's not just a project template: the engineering decisions about the stack, the structure, the tests and CI are already made, and further development runs through specs, skills and quality gates. The full breakdown: what is an Application Skeleton.
MakerKit and Supastarter are feature-rich SaaS boilerplates with agent instructions and testing support. Gridfin solves a different problem: it starts with your product idea and runs a spec-driven delivery process whose hooks block known violations, whose tests must be proven able to fail, and whose gate ledger records whether the whole change is ready. Choose them for prebuilt SaaS features; choose Gridfin for an enforced build process around a focused product.
Because the whole process — rules, hooks, tests, gates, playbooks — is proven on exactly this stack: Next.js + TypeScript, Tailwind + shadcn/ui, Postgres. Freedom to pick a stack is another forty decisions you'd have to make without the experience.
No — and that's deliberate. Gridfin is not a pick-your-own-stack kit: remove the fixed stack and everything built on it disappears — the proven rules, tests and gates. If you need a different stack, the honest answer is: Gridfin is not your tool.
You need Claude Code, Git, a terminal and the supported Node.js/pnpm toolchain. Gridfin runs locally as a git repository and does not require a hosted Gridfin account or a proprietary runtime.
Nothing terrible: the repository is yours, the code and the process work locally and don't depend on Gridfin existing as a product. Updates would stop coming — everything else stays.
If you're ready to work with a terminal, git and Claude Code by step-by-step instructions — yes: the box carries the architecture, the testing strategy and the quality control for you. If you're seeing a terminal for the first time — start with Lovable or Bolt.
Gridfin makes a mistake visible before the merge: every change passes lint, tests, e2e and build, and the rules are enforced by hooks and quality gates. The agent can write code fast, but it can't ship a change without the checks.
Get early access and start from a ready Application Skeleton, not an empty repository.
Get early access