DIXI Spec Kit vs GitHub Spec Kit: where ours goes further, and where it still falls short

By Alfredo Castillejos · Dixi-Project · November 12, 2026 · 14 min readUpdated on
Illustration: a small grid of nine blocks next to a grid of thirty-three, ten of them in the same color as the small one, and a check mark.

In our previous post we explained how we built our spec-driven development framework and closed with ten steps for another company to build its own. This post is the practical follow-up: you no longer have to build it from scratch. We released the method as open source, under the MIT license, as DIXI Spec Kit.

The obvious question is why another kit, when GitHub Spec Kit already exists: a mature project with close to 150 thousand stars and support for 41 agents. The short answer: Spec Kit handles the stretch from specification to code very well, and our method starts earlier and ends later. The long answer is this post, with dates, sources and the things we are still missing.

Updated on November 13, 2026 for version 1.11.1 of the kit: command and CLI references, the migration guide in Spanish, dixi mode and a /dixi.status that resumes the session.

What "goes further" means here

Saying one kit is more complete than another means nothing unless you say in what. We claim it in three specific senses, and only those:

  1. Lifecycle coverage. It covers what happens before you specify (discovery, domains) and what happens after you implement (verification, review, delivery, operations, compliance).
  2. Traceability checked by a machine. The chain from business goal to test is not a convention: a command fails when it breaks.
  3. Rules that fail on their own. The rules that protect the process can be installed as mechanisms that block the agent, not only as instructions the agent may ignore.

In other senses Spec Kit is the more complete one: more agents, more extensions, more community. We spell that out further down, because a comparison that only lists the favorable side is no help in choosing.

Where each kit comes from

The two kits answer different questions, and that explains almost every difference.

GitHub Spec Kit exists to get started with SDD on any agent: it installs commands that take you from an idea to a specification, a plan, a task list and an implementation. Its strength is breadth: it works with nearly everything and has an ecosystem of extensions around it.

DIXI Spec Kit comes out of a framework that was already in production. It is the public, portable version of AI-ASEE (internally, EIS-IA), the ecosystem we described in the previous post and use to build all our software. The premise is the same: with AI, the bottleneck is not generating code but validating it. That is why the kit spends as much on verifying, reviewing and tracing as it does on specifying.

First, parity: everything in Spec Kit has a counterpart

If you know Spec Kit, you lose nothing by switching. Every command has a counterpart with the same purpose:

GitHub Spec Kit DIXI Spec Kit What changes
/speckit.constitution /dixi.constitution Principles are versioned, with a change log, and every operation reads them. Removing or redefining one requires a written architecture decision
/speckit.specify /dixi.specify Each feature sits under a module and a domain, and dixi check verifies it
/speckit.clarify /dixi.clarify Answers stay in the specification
/speckit.plan /dixi.plan Depending on risk, it pulls in domain, architecture, contracts and a threat model
/speckit.checklist /dixi.checklist The build stops while items are open; a person ticks them
/speckit.tasks /dixi.tasks Each task carries a risk level and a link to the criterion it covers
/speckit.analyze /dixi.analyze Both only read and report
/speckit.implement /dixi.build One task at a time, with the failing test committed before the code
/speckit.converge /dixi.converge Both append convergence tasks without editing specs or code
/speckit.github.taskstoissues (extension) /dixi.issues Uses gh, and creates nothing until the person confirms a preview

There is a guide for people coming from Spec Kit, also in Spanish since version 1.10.0, with the command map, where each document lives and the steps to move an existing project.

Then, what it adds: 23 operations with no counterpart

DIXI Spec Kit installs 33 operations. Ten are the ones in the table above. The other 23 cover what lies outside the specify → implement stretch:

Stage Operations What they produce
Before specifying discover, interview, domain Product vision, actors and scope; domain boundaries and shared language
Design architecture, contract, data, threat-model, ai, quality Architecture decisions, contracts linked to their consumers, data classification, threats with a planned test for each, test strategy
Verify and review verify, review, risk-review Which checks ran, which failed and which did not run; findings by risk for human review
Continuity and change status, handoff, change, onboard, bugfix The justified next step and where the last session left off, a handoff between sessions, the impact of a change, draft specs from existing code and fixes with a failing test first
Delivery and operations release, promote, operate, finops Evidence that a release is ready, SLOs and runbooks, cost estimates with their assumptions
Compliance compliance, duediligence A map of obligations and pending evidence; a report backed by artifacts

One important limit: the delivery, operations and compliance operations only write documents. They never run migrations, deploy or claim a certification. They prepare the evidence; a person decides. The same goes for the project's mode: dixi mode (since version 1.11.0) shows whether the project is in mvp or prod and, for mvp, which of the six items /dixi.promote reviews (tests and budgets, threat model, data retention, runbooks and SLOs, release and rollback, owners) have no evidence yet. It is read-only: it has no option to change the mode.

And a caveat the kit itself carries in its catalog: the number of commands alone does not prove usefulness or quality. Thirty-three operations nobody verifies are worth less than nine that work. What matters is in the next three sections.

Traceability: the difference the command list doesn't show

In the previous post we said traceability is one of the two axes holding the framework together: every line in production can be followed back to its reason. In the kit that chain is explicit, and a command checks it:

goal → domain → module → feature → contract → test

dixi check walks the project and fails if a feature does not cite its module, if a module does not cite its domain, if a link points to a document that does not exist or if the chain is broken. It runs no code, uses no AI and needs no network: a mechanical check, the same on a laptop and in CI.

In Spec Kit, specify check checks something else: that the agent tools are installed. Consistency across artifacts is reviewed by /speckit.analyze, which is an agent command. The difference is one of kind, not degree: an agent's report is an opinion; a validator that exits with code 1 is a control. The kit has both and says which is which: analyze interprets semantic consistency and dixi check checks the mechanical rules.

A structural difference follows. Spec Kit organizes work by feature (specs/NNN-name/). DIXI organizes it in numbered folders that persist: domains, modules, features, contracts, data, decisions. Module-level specs that outlive the feature are an open request in Spec Kit (issue #1100); in DIXI they are 04-modules/.

Rules that fail on their own

The most expensive lesson in the previous post was this one: a rule that depends on someone remembering it is not a control. The kit hands that lesson to whoever installs it.

By default, as in Spec Kit, rules are instructions for the agent. With --controls, five hooks are installed that inspect every action before it happens:

Rule Without --controls With --controls
Do not edit a committed test Instruction Blocked by a hook
Do not read secrets Partial Blocked by a hook
Do not sign, approve or merge on a person's behalf Instruction Blocked by a hook
No destructive commands in production mode Instruction Blocked by a hook
Do not say "done" with verification failing Instruction Blocked by a hook (once; then the person decides)

They are the same five hooks we use ourselves, and they work in Claude Code and Codex.

Two qualifications, so we don't overpromise. Hooks are a second layer, not the last one: an agent can reach a file through a path a hook does not inspect, and the effective protection is still human review and branch protection. And they are opt-in: without --controls you get the same guarantees as with any instruction-based kit.

Tests first, and a person who answers

Two of the kit's rules have no counterpart in Spec Kit, and they change day-to-day work the most.

The test is frozen before the code. /dixi.build takes one task at a time: it writes the tests, shows that they fail for the expected reason and proposes recording them in their own commit. From then on they are frozen tests: the agent writes code until they pass and does not touch them. If a test looks wrong, it stops and explains. Without this, the shortest path to "green" is to adjust the test.

The agent does not sign, approve, merge or deploy. It prepares the change and the evidence; a named person reviews and merges it. The kit does not impose a branching strategy or create branches on its own either (in Spec Kit, configuring it without forking the commands is the request in issue #2047).

The process is also proportional, as in the framework it comes from: each task carries a level from 0 (fix) to 3 (structural), and a level 3 task needs a person's validation before it is built. Before starting a task, build checks the work-in-progress limit (three open PRs by default) and suggests finishing one before opening another. And dixi pr-size measures the branch against a 1,500-line maximum, not counting tests or documentation.

Profiles: what the project is born with

Spec Kit installs commands and templates for its artifacts. DIXI also installs the project's document base according to its size:

Profile For Templates
minimal (default) Trying the method The 16-file base
site Landing page or content site with no backend of its own 77
app Site, admin panel, API and one database 190
platform Several services, events or teams 241
--regulated Added to any of them: payments, health, sensitive data Up to 273, with GDPR, SOC 2, ISO 27001, HIPAA and PCI DSS

Templates are guides with marked gaps, not decisions already made: delete the ones that do not apply, and dixi placeholders lists what is left to fill in. Everything ships in English and Spanish, including the commands and the CLI messages.

Existing projects and aging projects

A kit is tested less on the day you install it than six months later. Four differences here:

  • Adopting an existing repository. dixi init --existing adds the kit to a folder that already has files without overwriting any of them, and /dixi.onboard drafts modules and features from the code, with file-and-line evidence, for a person to validate.
  • Upgrading an initialized project. dixi upgrade --dry-run shows what the new kit version would change; dixi upgrade --apply writes only the kit files you have not edited, one by one and atomically. In Spec Kit, specify self upgrade upgrades the tool; a procedure for already-initialized projects is an open request (issue #1210).
  • Fixing without losing the trail. /dixi.bugfix requires a test that reproduces the bug, committed before the fix, and leaves a record linked to the feature.
  • Picking up where you left off. Since version 1.11.0, /dixi.status does more than suggest the next step: it reports what the last session did and left open (when a handoff was written), the recent contract changes from the Git history and the open tasks by ID. It only reads: no writes, commits or pushes.

Less surface

A design decision that looks minor: the CLI has no dependencies (Python standard library only), uses no network, consumes no AI and asks for no credentials. Every write refuses symlinks, and on native Windows the command exits with an error code instead of writing with weaker guarantees (Windows works through WSL 2, verified in CI).

For a tool installed on the machine where the code and the secrets live, fewer parts means less to audit.

The ten steps from the previous post, already done

We ended the previous post with ten steps to build your own SDD framework. Here is what the kit gives you for each one, and what it does not:

Step What the kit ships
1. Start with the premise /dixi.discover and /dixi.constitution: vision and versioned principles
2. A model with owners Governance templates in the profiles. You name the owner
3. The short list of non-negotiables The limits every operation repeats, and the support matrix, which states what is automatic and what is an instruction
4. Rules turned into mechanisms --controls: five hooks for Claude Code and Codex
5. Verifiable traceability dixi check and .dixi/traceability.json
6. Standard separated from project, and versioned dixi upgrade tells kit files from your edits; dixi preset replaces kit texts with your team's
7. A person behind every change The agent does not sign or merge. The second review is enforced by your repository's branch protection, not by the kit
8. Proportional process Risk levels 0 to 3 on every task
9. Work-in-progress limit build checks it before starting (three by default)
10. Measure PR size only, with dixi pr-size. Lead time and rework are out of scope

What the kit does not ship from our framework is the deployment chain: the pipeline gates that check signatures and attestation after the merge depend on each company's cloud. The kit provides the templates to document it, not the infrastructure.

Where GitHub Spec Kit is ahead

Area GitHub Spec Kit DIXI Spec Kit
Agents 41 integrations, plus generic and none Claude Code and Codex verified; an Agent Skills adapter verified in OpenCode and format compatible, not verified, for Cursor, VS Code/Copilot, Gemini CLI and others
Extensibility Extensions, presets, workflows, bundles and catalogs; the project lists 186 community extensions and 42 presets Local, data-only extensions and presets. No catalogs
Workflows Executable and resumable, with human review gates dixi workflow prepares the context for each operation; the agent runs it
MCP Experimental read-only server None
Systems Windows, macOS and Linux macOS and Linux; Windows only through WSL 2
README languages English, Chinese, Japanese and Korean English and Spanish
Community and maturity Close to 150 thousand stars; version 1.4.0 First public release on November 8, 2026; version 1.11.1 five days later

That last row weighs the most. A project with one week of public life has not been through what a project used by thousands of teams has, no matter how many tests it ships.

Which one to choose

  • Choose GitHub Spec Kit if your agent is neither Claude Code nor Codex, if you work on native Windows, if you want to lean on a community extension catalog or if you need executable workflows.
  • Choose DIXI Spec Kit if you need specifications to outlive the feature, traceability checked by a machine, rules that block the agent instead of asking it to behave, or if your project has to document security, operations and compliance as well as code. Also if your team works in Spanish.
  • You can use both. They live in different folders (.specify/ and specs/ against the numbered folders and .dixi/). Moving a project from one to the other is a manual mapping, reviewed by a person at every step.

Getting started

It requires Python 3.11 or later, on macOS or Linux:

uv tool install dixi-spec-kit        # or: pipx install dixi-spec-kit
dixi init my-project --agent claude --profile app --controls
cd my-project
dixi doctor && dixi check

Then, in the agent:

/dixi.discover <your idea>
/dixi.specify <feature>
/dixi.plan <feature ID>
/dixi.tasks <feature ID>
/dixi.build <task ID>
/dixi.verify
/dixi.review main

The repository ships two complete examples, from idea to tests: a notes library and a Next.js site in two languages. The documentation is available in English and Spanish.

Since version 1.10.0 the documentation is more than the README. It ships a command guide with the journey map and a table of which command to use when; a reference with one page per operation (what it is for, when to use it, what it reads and writes, where it stops and an example for Claude Code, Codex and Agent Skills); and a CLI reference with every command, option and exit code. Both references are generated from the real command texts and argument parser, and a test fails when a page is missing or out of date: the same idea as the rest of the kit, applied to its own documentation.

What this post does not claim

  • It does not claim GitHub Spec Kit is a bad project. It opened the path, and in agents, extensions and community it is far ahead.
  • It does not claim more operations is better. It claims the method covers more stages of the lifecycle and checks more things with mechanisms. If your project only needs to go from specification to code, the difference will matter little.
  • It does not claim hooks are infallible. They are a second layer. The first is still a person who reviews.
  • It does not claim the Spec Kit figures are still current. They come from a fast-moving project. They are dated; verify them before reusing them.

Sources

  • DIXI Spec Kit, version 1.11.1 (November 13, 2026): repository, Spec Kit comparison, support matrix, changelog (versions 1.9.0 to 1.11.1), roadmap and architecture decision ADR-108 on Spec Kit parity.
  • GitHub Spec Kit, version 1.4.0 (November 10, 2026): repository, its command templates, its integrations documentation and issues #1100, #1210 and #2047, open as of November 13, 2026. The extension and preset figures are the ones the project published on November 11, 2026.
  • Dixi-Project: Inside our spec-driven development framework (2026).
ShareLinkedInXWhatsApp