DexanKit

Spec-driven development orchestration for AI-assisted coding. DexanKit gives your AI editor a structured workflow — from feature spec to verified, committed code.

Works with Antigravity, Claude Code, Cursor, and GitHub Copilot.

Quick Start

# New project
npx @aam-tech/dexankit init myproject

# Existing project
cd myproject && npx @aam-tech/dexankit init .

Select your AI editor, and DexanKit generates the rules, skills, and config your editor needs. Then use the skills directly in your editor.

Workflow

/dexankit-new        Scaffold project from company templates
       ↓
/dexankit-define     Define a feature spec (PRD + technical)
       ↓
/dexankit-plan       Create implementation plan (max 3 tasks)
       ↓
/dexankit-exec       Execute plan — code, test, commit per task
       ↓
/dexankit-verify     Verify against acceptance criteria

Utilities

/dexankit-quick      Fast-track small changes (≤3 files)
/dexankit-rollback   Undo recent changes safely

What It Does

/dexankit-new <description>

Describe your project and DexanKit figures out the components:

/dexankit-new build an order management system with admin dashboard and nightly report jobs

The AI analyzes the description and determines:

• Backend — Go (default) or Node.js
• Frontend — NextJS with shadcn/ui
• Scheduler — for cron jobs, queue workers, batch processing

Each component is cloned from company template repos, dependencies are installed (go mod tidy / npm install), and git is initialized per component folder — backend and frontend push to separate repos.

/dexankit-define

Defines a feature spec with:

• Background & business context
• User stories
• Acceptance criteria
• Technical notes per component
• Dependencies, out of scope, success metrics

The define is the single source of truth. Plan and exec depend on it.

/dexankit-plan

Reads the define, scans affected code, and generates a concrete plan:

• Max 3 tasks per plan (split into multiple plans if larger)
• Each task: target component, exact file paths, what to do, what to test
• Creates feature branches inside each component folder

/dexankit-exec

Executes the plan task by task:

1. Implement code changes
2. Write unit tests
3. Run tests (go test / vitest)
4. Commit on pass, retry or rollback on fail
5. Checkpoint progress in STATE.md (resumable)

/dexankit-verify

Before pushing, verifies:

• Every acceptance criterion is implemented and tested
• Code quality: no TODOs, no hardcoded secrets, meaningful tests
• Full test suite passes
• Outputs a PASS/FAIL report

/dexankit-quick

Skip the full workflow for small changes:

/dexankit-quick fix the date format bug in order list API

Auto-detects component, implements, tests, commits — all in one step. Max 3 files.

/dexankit-rollback

Guided rollback with options:

• Undo last commit
• Reset to a specific commit
• Switch back to main branch
• Discard unstaged changes

Project Structure

After init, DexanKit creates:

project/
├── dexankit/
│   ├── config.json          # Project config (name, editor, components)
│   ├── STATE.md             # Session continuity — where things left off
│   ├── PROJECT.md           # Living doc — overview, components, decisions
│   ├── rules/
│   │   └── standards.md     # Cross-cutting development standards
│   ├── skills/              # Canonical copies of all skills
│   ├── defines/             # Feature specs
│   └── plans/               # Implementation plans
├── .agents/                  # ← or .cursor/ .agents/ .github/
│   ├── rules/
│   │   └── dexankit.md      # Editor rules with frontmatter
│   └── skills/
│       ├── dexankit-new.md
│       ├── dexankit-define.md
│       ├── dexankit-plan.md
│       ├── dexankit-exec.md
│       ├── dexankit-verify.md
│       ├── dexankit-quick.md
│       └── dexankit-rollback.md

Hybrid Rules Architecture

DexanKit uses a two-level rules system:

• Root level (dexankit/) — workflow skills, cross-cutting standards, state tracking
• Component level (backend/, frontend/) — stack-specific rules baked into each template repo

When the AI works on a component, it reads that component's own rules for conventions, patterns, and file structure. DexanKit's root rules handle the orchestration.

Stack

| Component | Architecture | Framework | ORM | DB | Cache | Test | |-----------|-------------|-----------|-----|-----|-------|------| | Go Backend | Clean Architecture | Go Fiber | GORM | MySQL, Oracle | Redis | go test | | Node.js Backend | Clean Architecture | Hono.js | Knex.js | MySQL, Oracle | Redis | Vitest | | NextJS Frontend | Clean Architecture | shadcn/ui | — | — | — | Vitest |

Git Strategy

• Git is initialized inside each component folder (backend/.git, frontend/.git)
• Each component pushes to its own remote repo
• Branch naming: feature/<name>, fix/<name>, refactor/<name>
• Conventional commits: feat(<scope>): description
• One commit per task during /dexankit-exec

Supported Editors

| Editor | Rules Dir | Skills Dir | |--------|-----------|------------| | Antigravity | .agents/rules/ | .agents/skills/ | | Claude Code | .claude/rules/ | .claude/skills/ | | Cursor | .cursor/rules/ | .cursor/skills/ | | GitHub Copilot | .github/instructions/ | .github/skills/ |

Token Efficiency

Each skill declares exactly which files to load — no unnecessary context:

• /dexankit-new loads only config.json
• /dexankit-exec loads only STATE.md, the plan, and component rules
• /dexankit-verify loads only state, plan, define, and modified files

This keeps AI token usage low and responses focused.

Requirements

• Node.js 20+
• Git
• Access to company GitLab template repos (for /dexankit-new)

License

MIT