Why I made it
I’ve been writing software for many years and starting things for most of my life. Coding agents changed how I build: ideas that used to wait for a team or a free month now get a real first version. Along the way I kept writing the same instructions to agents, and kept finding the same kinds of bugs after they said “done”. Keelokit is what came out of fixing that, one project at a time.
The idea
The rules that matter shouldn’t live only in a prompt. In Keelokit each rule points to something that checks it (a test, a lint rule, a git hook, a CI job) and a small script tells you when a rule has lost its check. What nobody knows yet is written down as an open question instead of being guessed, and the agent that writes the code isn’t the one that says it’s done. Bugs come in classes, so the rules that must always hold (totals add up, a notice goes out once, a limit holds with two requests at once) are written down and proven with tests built to break them.
What it does
| Command | What happens |
|---|---|
/keelokit:project-new | From an idea to a working skeleton: an interview that writes the product context, a short PRD, the stack, a generated monorepo with CI, and a first backlog |
/keelokit:project-adopt | Adds only the harness to a repo you already have, and lists what it doesn’t meet yet as dated exceptions |
/keelokit:build-story | One story at a time: a verifier writes the acceptance tests first, a builder makes them pass, a reviewer reads the diff, a breaker tries to break it, and the verifier walks it in the running app |
/keelokit:check-bugbash | A bug hunt across data, API, integrity, UX, translations, accessibility, security and more; every bug that got through adds a check for its whole class, so it doesn’t come back |
/keelokit:project-dashboard | One page, rebuilt from the repo, to follow the project: every stage and its status, what waits for your review, stories by wave and by epic, bug bashes, the decisions taken, and buttons that ask Claude for the next step |
See all commandsShow less
| Command | What happens |
|---|---|
/keelokit:plan-intake | Reads what you already have (briefs, notes, a repo), then asks only what’s missing; what nobody knows yet is written down as an open question with an owner |
/keelokit:plan-backlog | Epics and stories with acceptance scenarios and the rules they must keep, grouped into waves so work running in parallel never touches the same files |
/keelokit:check-health | Checks that every rule still has a working check; adds a new rule with its check, or registers a dated exception |
/keelokit:check-security | Security and privacy in depth: a map of the personal data, the privacy law of each market, abuse of the critical journeys, dependency and staging scans; every problem fixed with a test and a check that covers its class |
/keelokit:ship-setup | Staging and production for people who have never deployed: a guide with a checklist per environment, the steps that need no credentials done for you, and each one verified |
/keelokit:ship-release | A version people can name, read about and roll back to: notes from what landed, a tag after your yes, and production only after a person approves it |
/keelokit:harness-upgrade | Maintenance of the harness, not of your app: brings Keelokit’s newer rules and checks into your project, on a branch, without touching its product code |
/keelokit | Where the project stands, what comes next, and what’s waiting for your decision |
The agents it uses
| Agent | Its job |
|---|---|
| Verifier | Writes the acceptance tests before any code exists, and is the only one that can say a story is done, after walking it in the running app |
| Reviewer | Reads each change cold, against the story and the rules, without having written it |
| Breaker | Attacks each story before it lands: double submits, simultaneous requests, replays, another customer’s data |
| Context auditor | Reviews the product context for invented facts, vague wording and contradictions before anything is built on it |
What runs on its own
| When | What |
|---|---|
| Before every agent action | A guard stops secrets, edits to .env files and to migrations already applied, skipped git hooks, silenced tests and production deploys |
| When a session starts | A short status: where the project is and which stories are ready |
| At every stage | The dashboard refreshes; in automatic mode Keelokit goes on by itself and stops only where a person is required |
| On every commit and push | The same guard as a git hook, then the full local check before anything reaches the remote |
| In CI | Secret scan, lint and types, unit tests, integration tests on a real PostgreSQL, end-to-end journeys with an accessibility scan and against the real API, mutation testing of the critical code, static analysis, and a staging deploy |
The stack it generates is the one I like to build with: pnpm workspaces, TypeScript, NestJS with Prisma and PostgreSQL, Vite and React, Expo, and Astro.
Who it’s for
People taking their first steps with agents, and founders and teams, technical or not, laying the foundation of a first MVP. It’s opinionated and built around my preferences, so it won’t fit every project or every team. Take what’s useful.
Try it
Keelokit has its own site: keelokit.com. The code, the instructions and the license (MIT) are on GitHub: github.com/leosimini/keelokit. Issues and discussions are open there.