karni
Karni is an open-source Django + React framework for building with AI coding agents. Your agent writes only your domain. The API, admin, permissions and React screens come from a package you upgrade, not code it rewrites in each project. One rule set covers every coding agent.
Install / Use
claude mcp add cbsshekhawat18-lab -- npx -y github:cbsshekhawat18-lab/karniIf the server publishes to npm under a different name, use that package instead β check the repo README.
MCP Server
Model Context Protocol server
Quality Score
Category
Data & AnalyticsSupported Platforms
Our assessment of karni
karni scores 84/100 on our quality scale, 470th of 608 Data & Analytics skills we index.
Its MCP Server is 22 KB long, well organised into 13 sections with 6 code examples: a thorough specification that gives an agent plenty to work with.
It has 10 GitHub stars, so there is little community track record yet; judge it on its content.
Maintenance, license and trust
- The repository was last updated 2 days ago, so karni is actively maintained.
- It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 97/100, with no cautions. These come from repository metadata, not a code audit β read the skill file before letting an agent act on it.
karni compared with similar skills
All 4 of these similar skills score higher than karni; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| karni (this skill)by cbsshekhawat18-lab | 84 | 10 | 2d ago | MCP Server |
| claude-memby thedotmack | 100 | 117.9k | today | CLAUDE.md |
| Agent-Reachby Panniantong | 100 | 112.7k | 9d ago | CLAUDE.md |
| rufloby ruvnet | 100 | 82.0k | today | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 79.9k | today | CLAUDE.md |
Frequently asked questions
- How do I install karni?
- Run
claude mcp add cbsshekhawat18-lab -- npx -y github:cbsshekhawat18-lab/karni. The install tabs above show the steps for each supported agent. - Which AI agents does karni work with?
- It is written for Claude Code and Claude Desktop, as a MCP Server file. Other agents that read the same format can often use it too.
- Is karni safe to use?
- It is Apache-2.0-licensed and scores 97/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is karni still maintained?
- The repository was last updated 2 days ago, so karni is actively maintained.
Skill content
View source on GitHubWhy Karni exists
Every web project starts with the same work: sign-in, a user model, the admin, permissions, CRUD endpoints, tables, forms, Docker and Celery. Only after that does the work on the product begin.
Coding agents write that setup faster, but they write it again in every project. Each copy is a little different, with the hard parts wrong in different places, and every copy has to be maintained. Karni grew out of the 34 projects we built before it.
What is Karni
The problem. Every Django + React project needs the same code before it does anything of its own: serializers, permission classes, admin files, sign-in pages, tables and forms. A boilerplate copies it once. A coding agent writes it again in every project. Either way, a fix made upstream never reaches the copies.
How Karni solves it. That code ships as versioned packages: karni (Python), @karni/ui (React) and the karni command. karni upgrade moves a project to each new release, so a fix reaches every project that depends on Karni.
What you get. You declare a model and who may access it. Karni gives you the REST API, the admin, role-based access, the React screens, the tests and the demo data.
What you still write. Your domain: your models, the rules for who may do what, and the logic and pages your product needs. AGENTS.md tells the agent the same, and karni check fails the build when it hand-writes what Karni ships.
Build an app from one line
- Create a project with
karni new "Yoga Studio"and open it in your coding agent. - Describe the app in one line after
/new-app. AGENTS.md tells the agent what that asks for. - The agent writes
karni.yamlfrom the closest recipe, and asks you only the questionskarni plan --questionslists. karni buildmakes the app: it adds the modules, writes Karni's code, migrates, seeds the demo data the spec asks for, generates the TypeScript types, and runs the tests andkarni check.- The agent writes only the domain logic that is left, in the project's own files. It is done when
karni checkandkarni testpass.
/new-app a booking app for a yoga studio, with online payments
What the agent runs, from a real session:
$ karni recipes list --match "a booking app for a yoga studio, with online payments"
booking 4 Booking: Resources with time slots that members book and pay for, never over capacity. (matched: booking)
shop 3 Online shop: Products in categories, a cart, orders and checkout with online payments. (matched: online, payment)
$ karni plan --questions
No questions: karni.yaml settles everything Karni asks before a build.
$ karni build
plan 22 changes, 0 risky: modules 1, features 1, roles 3, apps 1, entities 3, access 3, pages 3, migrations 1, seed 3, tests 3 (--verbose lists each)
modules karni add payments
files 27 written: 17 Karni's, 10 the project's (pyproject.toml, frontend/package.json, ...)
migrations bookings/migrations/0001_initial.py
migrate applied 84 on default
seed Resource 4, Slot 30, Booking 60 (demo login demo@example.com / karni-password)
types frontend/src/api/types.ts and hooks.ts
test 7 passed in 2.88s, tests/openapi.snapshot.json updated (the API changed: commit it)
check ok
Built: the project matches karni.yaml.
On a developer laptop, karni new --recipe shop builds the shop from scratch on SQLite in 14.1 seconds, its tests and karni check included and the frontend install left out (how fast is it). The flow works without an agent too: every step is a command you can run yourself. The recording below builds a project command by command, then shows its welcome page, its admin and its React screens.
Coding-agent benchmark
A coding agent built three small apps (a booking app with payments, a CRM with three roles and import, and a shop with orders and refunds) on plain Django + React and on Karni, with the same model, agent version, prompt and API contract. The harness's own acceptance tests decide success.
What the agent built
One kept run per app and side, each passing every acceptance test, on the Karni 0.5.0 release. Both sides are measured the same way, by the project's own Django and its files (scripts/benchmarks/tokens/inventory.py):
| In the finished app | Plain Django + React | Karni | |---|---|---| | API operations (route and method) | 22 to 25 | 71 to 135 | | Sign-in and account endpoints, outside the admin | 1 to 2 | 16 | | Models in the admin | 1 to 2 | 26 to 30 | | React screens | none | 9 to 12 | | Tests the project ships with | none | 7 to 15 | | OpenAPI schema served | no | yes | | Typed API client in the frontend | no | yes | | Production Docker stack | no | yes | | Rules for the coding agent | no | yes |
<!-- bench:inventory:end -->Why a Karni run costs more. These tasks check only a small API contract. Plain Django meets it and stops there: no screens, no tests, and two sign-in endpoints at most. With Karni, the same request ends in the whole app above, and the agent also reads Karni's rules and runs its build and checks. So a Karni run costs more and takes longer (below), and for that the app has about 3 to 5 times the API operations, a full sign-in, an admin, React screens and tests.
What it cost
45 runs: five per app on plain Django + React, on the Karni 0.5.0 candidate, and on Karni after the work on its agent flow.
<!-- bench:readme:start -->| Task | Plain Django + React | Karni 0.5.0 candidate | Karni after the agent-flow work | |---|---|---|---| | Booking with payments | $0.19, 61.76 s, 5 of 5 passed, 5 tool calls | $0.45, 208 s, 3 of 5 passed, 26 tool calls | $0.33, 187 s, 5 of 5 passed, 20 tool calls | | A CRM with three roles and import | $0.21, 70.51 s, 5 of 5 passed, 6 tool calls | $0.56, 278 s, 5 of 5 passed, 31 tool calls | $0.40, 236 s, 5 of 5 passed, 22 tool calls | | A shop with orders and refunds | $0.23, 72.21 s, 5 of 5 passed, 7 tool calls | $0.62, 238 s, 4 of 5 passed, 29 tool calls | $0.44, 255 s, 4 of 5 passed, 24 tool calls | | All three tasks | $0.63, 204 s, 15 of 15 passed, 18 tool calls | $1.63, 724 s, 12 of 15 passed, 86 tool calls | $1.17, 678 s, 14 of 15 passed, 66 tool calls |
Each cell: median cost in US dollars, median wall time, runs that passed every acceptance test, and median tool calls. In the last row the runs add up and the other figures are the sums of the task medians, as the benchmark report gives them.
<!-- bench:readme:end -->- Plain Django + React was cheaper and faster on these three small apps. Karni after the agent-flow work cost about 1.8 to 1.9 times as much per app (median) and took about 3 to 3.5 times as long.
- The agent-flow work cut the median cost by 27 to 30 percent and the context the agent read again by 30 to 43 percent, and raised the runs that passed every test from 12 of 15 to 14 of 15.
- With Karni the agent wrote fewer lines of its own (median 256 to 431 per app, against 438 to 554), and each Karni project ended with far more code in it (median about 11,500 to 20,000 lines, most of it generated by Karni, against about 440 to 570).
Not counted here: setting up. Both sides started from a ready-made project; the harness, not the agent, made plain's Django and React starting point. Without Karni, that setup is done again for every new project. With Karni, karni new does it, and builds what the first table shows, with no AI tokens. A benchmark that starts from an empty folder and a one-line request is next.
The benchmark report has every figure with its range, the method, the limits, the commands to repeat it and the raw data.
What you get
Every feature, grouped by what you need. The features page lists all of them with their status.
<table> <tr> <td width="50%" valign="top">Start fast
karni new: a Django + React project, its settings in one call, Docker Compose and a Makefile- Recipes: six ready apps, from a shop to a data portal
karni.yaml: the app in one small file, withkarni planandkarni build- Generators:
karni make app,make model,make page - Demo data with
karni seed, and real content withkarni load - A public website next to the app, from a designer's pages
Data and access
BaseModel: UUID key, timestamps, soft delete, audit fields- Typed fields the database enforces: money, percent, phone, country
- States, capacity and no-overlap rules in the database
BaseViewSetwith a requiredaccessrule, applied to the queryset- [Account
Truncated for display β read the full file on GitHub.
Related Skills
claude-mem
117.9kPersistent Context Across Sessions for Every Agent β Captures everything your agent does during sessions, compresses it with AI, and injects relevant context back into future sessions. Works with Claude Code, OpenClaw, Codex, Gemini, Hermes, Copilot, OpenCode + More
Agent-Reach
112.7kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu β one CLI, zero API fees.
ruflo
82.0kπ The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
headroom
79.9kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit β see the Safety scan above for what the skill file itself contains.
