🎩 You're Invited:Meet the Socket team at Black Hat in Las Vegas, August 3-6.RSVP →

omgkit

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

omgkit

Omega-Level Development Kit - AI Team System for Claude Code. 41 agents, 174 commands, 162 skills, 69 workflows.

latest

Source

npm

Version: 2.33.1

Version published: 7 months ago

Weekly downloads: 126

Maintainers: 1

Weekly downloads

Created: 7 months ago

Source

OMGKIT - Omega-Level Development Kit

AI Team System for Claude Code

"Think Omega. Build Omega. Be Omega."

What is OMGKIT?

OMGKIT (Omega-Level Development Kit) transforms Claude Code into an autonomous AI development team. It provides a complete ecosystem of specialized AI agents, slash commands, skills, and workflows that work together to deliver 10x-1000x productivity improvements.

The Vision

Traditional AI assistants respond to prompts. OMGKIT creates an AI Team that:

Plans like a senior architect
Researches like a staff engineer
Codes like a full-stack developer
Reviews like a security expert
Tests like a QA specialist
Documents like a technical writer
Ships like a DevOps engineer

All coordinated through Omega-level thinking - a framework for finding breakthrough solutions rather than incremental improvements.

Key Numbers

Component	Count	Description
Agents	41	Specialized AI team members with distinct roles
Commands	174	Slash commands for every development task
Workflows	69	Complete development processes from idea to deploy
Skills	162	Domain expertise modules across 24 categories
Modes	10	Behavioral configurations for different contexts
Themes	30	Curated design system themes (V2 schema with color scales)
Archetypes	14	Project templates for autonomous development

Core Concepts

1. Optimized Alignment Principle (OAP)

OMGKIT uses a 5-level component hierarchy ensuring consistency and maintainability:

Level 0: MCPs (Foundation)
    ↓
Level 1: Commands → use MCPs
    ↓
Level 2: Skills → use Commands, MCPs
    ↓
Level 3: Agents → use Skills, Commands, MCPs
    ↓
Level 4: Workflows → use Agents, Skills, Commands, MCPs

Each level builds on lower levels, creating a coherent system where components work together seamlessly.

2. Omega Philosophy

Seven principles guide OMGKIT's approach to problem-solving:

Principle	Focus
Leverage Multiplication	Build systems, not features
Transcendent Abstraction	Solve classes of problems, not instances
Agentic Decomposition	Orchestrate specialists
Feedback Acceleration	Compress learning loops
Zero-Marginal-Cost Scaling	Build once, scale infinitely
Emergent Intelligence	System greater than sum of parts
Aesthetic Perfection	Excellence in everything

3. Sprint Management

OMGKIT brings agile methodology to AI-assisted development:

Vision: Define what you're building and why
Backlog: Prioritized list of work items
Sprints: Time-boxed development cycles
AI Team: Autonomous execution with human oversight

4. Reference-Aware Planning (New)

Use PRDs, specs, and design documents to inform sprint planning:

# Create sprint with PRD reference
/sprint:sprint-new "Auth Sprint" --ref=.omgkit/artifacts/prd-auth.md

# Sprint with multiple references
/sprint:sprint-new "Payment" --ref=artifacts/prd.md,specs/api.yaml

# Sprint with AI proposal based on references
/sprint:sprint-new "MVP" --propose --ref=.omgkit/artifacts/

Configure in .omgkit/workflow.yaml:

references:
  enabled: true
  auto_suggest: true
  max_tokens: 10000
  extract_sections:
    - requirements
    - user_stories
    - acceptance_criteria

References automatically propagate to /sprint:team-run and /sprint:backlog-add.

5. Testing Automation

OMGKIT includes a comprehensive testing automation system:

Auto-Generate Test Tasks

When you create a feature, OMGKIT automatically generates corresponding test tasks:

# workflow.yaml
testing:
  auto_generate_tasks: true
  required_test_types:
    - unit
    - integration

Feature tasks automatically spawn test tasks based on feature type (API → Contract tests, UI → Snapshot tests, etc.)

Enforce Tests Before Done

No task can be marked "done" without passing tests:

testing:
  enforcement:
    level: standard  # soft | standard | strict
  blocking:
    on_test_failure: true
    on_coverage_below_minimum: true

Coverage Gates

Set minimum and target coverage thresholds:

testing:
  coverage_gates:
    unit:
      minimum: 80
      target: 90
    integration:
      minimum: 60
      target: 75
    overall:
      minimum: 75
      target: 85

6. Design System

OMGKIT includes a complete design system with 30 curated V2 themes for shadcn/ui integration. All themes use the V2 schema with 12-step color scales, effects, and animations.

# Initialize with a theme (opt-in)
omgkit init --theme neo-tokyo

# Or explore themes first
omgkit init --with-design

V2 Theme Features

All 30 themes include:

Feature	Description
12-step color scales	`--primary-1` through `--primary-12`
Alpha variants	`--primary-a1` through `--primary-a12`
Status colors	`--success`, `--warning`, `--info`, `--destructive`
Effects	glassMorphism, glow, gradients
Animations	shimmer, pulse-glow, fade-in, slide-up
Backward compatibility	Includes flat `colors` block for legacy support

5 Theme Categories

Category	Themes	Description
Tech & AI	neo-tokyo, electric-cyan, neural-dark, matrix-green, quantum-purple, hologram	Futuristic, cyberpunk-inspired
Minimal & Clean	minimal-slate, paper, mono, zen, nordic, swiss	Simple, elegant, distraction-free
Corporate	ocean-blue, corporate-indigo, finance, legal, healthcare, consulting	Professional, trustworthy
Creative & Bold	coral-sunset, candy, neon, gradient-dream, retro, studio	Vibrant, expressive
Nature & Organic	forest, ocean, desert, lavender, arctic, autumn	Earth tones, calming

Design Commands

Command	Description
`/design:themes`	List all 30 curated themes
`/design:theme <id>`	Apply a theme to your project
`/design:preview`	Preview current theme colors
`/design:builder`	Build custom theme interactively
`/design:from-screenshot`	Extract theme from image
`/design:from-url`	Extract theme from webpage
`/design:add <comp>`	Add shadcn/ui components
`/design:reset`	Reset to original theme
`/design:rebuild <id>`	Rebuild entire project with new theme
`/design:scan`	Scan for non-compliant colors
`/design:rollback`	Rollback to previous theme
`/design:export <format>`	Export to CSS, SCSS, Tailwind, Figma, Style Dictionary
`/design:validate`	Validate theme structure

Theme Export

Export your theme to various design tools and framework formats:

# Export CSS
/design:export css

# Export Figma tokens
/design:export figma --output ./tokens/

# Export all formats
/design:export --all

Supported formats: css, scss, tailwind, figma, style-dictionary

Theme Rebuild

Rebuild your entire project's UI with a single command:

# Rebuild with new theme (scans and fixes hardcoded colors)
omgkit design:rebuild neo-tokyo

# Full auto mode - zero manual steps, scans ALL directories
omgkit design:rebuild neo-tokyo --full

# Preview changes without applying
omgkit design:rebuild neo-tokyo --dry

# Scan for non-compliant colors
omgkit design:scan

# Rollback if needed
omgkit design:rollback

The rebuild feature:

Backs up current theme before changes
Standard mode: Scans app/, components/, src/, pages/ directories
Full mode (--full): Scans ALL directories including tests/, lib/, utils/, hooks/
Replaces hardcoded colors (bg-blue-500) with theme variables (bg-primary)
Full mode: 200+ extended color mappings with AI-driven inference
Full mode: Safely updates test files (skips assertion strings)
Generates 12-step color scales and status colors

Generated CSS Variables

/* 12-step color scales */
--rose-1 through --rose-12
--rose-a1 through --rose-a12  /* Alpha variants */

/* Status colors */
--success, --warning, --info

/* Effects */
--glass-blur, --glow

/* Animations */
@keyframes shimmer { ... }
--animation-shimmer

How It Works

OMGKIT provides CSS variables that shadcn/ui components consume:

.omgkit/design/theme.json  →  Theme configuration (V2)
.omgkit/design/theme.css   →  CSS variables (:root + .dark)

After applying a theme, use npx shadcn@latest add button to add components that automatically use your theme colors.

Installation

Prerequisites

Node.js 18+
Claude Code CLI installed and authenticated

Install OMGKIT

# Install globally
npm install -g omgkit

# Install Claude Code plugin
omgkit install

# Initialize in your project
cd your-project
omgkit init

Verify Installation

omgkit doctor

Quick Start

After installation, use these commands in Claude Code:

# 1. Set your product vision
/vision:set

# 2. Create a sprint with AI-proposed tasks
/sprint:new --propose

# 3. Start the AI team
/team:run

# 4. Or use individual commands
/feature "add user authentication"
/fix "login not working"
/10x "improve performance"

Agents (41)

Agents are specialized AI team members, each with distinct expertise and responsibilities.

Core Development

Agent	Description	Key Skills
`planner`	Task decomposition, implementation planning	Writing plans, task breakdown
`researcher`	Technology research, best practices	Documentation analysis, comparisons
`debugger`	Error analysis, root cause finding	RAPID methodology, log analysis
`tester`	Test generation, coverage analysis	Framework-specific testing
`code-reviewer`	Code review with security focus	OWASP checks, severity rating
`scout`	Codebase exploration, file search	Pattern discovery, architecture mapping
`fullstack-developer`	Full implementation	All development skills

Operations

Agent	Description
`git-manager`	Conventional commits, PR automation, branch management
`docs-manager`	API docs, architecture guides, automated doc generation
`project-manager`	Progress tracking, coordination, status reports
`database-admin`	Schema design, query optimization, migrations
`ui-ux-designer`	UI components, responsive design, accessibility
`observability-engineer`	Monitoring, logging, tracing, alerting, SLOs

Architecture & Platform

Agent	Description
`architect`	System design, leverage multiplication, ADRs
`domain-decomposer`	DDD, bounded contexts, service boundaries
`platform-engineer`	Internal developer platforms, golden paths
`performance-engineer`	Profiling, load testing, optimization

Security

Agent	Description
`security-auditor`	Security reviews, vulnerability assessment
`vulnerability-scanner`	Security scanning, dependency audit
`devsecops`	Security automation, SAST/DAST integration

Data & ML

Agent	Description
`data-engineer`	Data pipelines, ETL, schema design
`ml-engineer`	ML pipelines, model training, MLOps

ML Systems (New)

Agent	Description
`ml-engineer-agent`	Full-stack ML engineering from data to deployment
`data-scientist-agent`	Statistical modeling, experimentation, analysis
`research-scientist-agent`	Novel algorithms, paper implementation, experiments
`model-optimizer-agent`	Quantization, pruning, distillation
`production-engineer-agent`	Model serving, reliability, scaling
`mlops-engineer-agent`	ML infrastructure, pipelines, monitoring
`ai-architect-agent`	ML system architecture, requirements analysis
`experiment-analyst-agent`	Experiment tracking, analysis, reporting

Specialized Domains

Agent	Description
`game-systems-designer`	Game mechanics, balancing, multiplayer
`embedded-systems`	Firmware, RTOS, IoT connectivity
`scientific-computing`	Numerical methods, simulations

Omega Exclusive

Agent	Description
`oracle`	Deep analysis with 7 Omega thinking modes
`sprint-master`	Sprint management, team orchestration

Commands (174)

Commands are slash-prefixed actions organized by namespace.

Development (`/dev:*`)

/dev:feature <desc>     # Full feature development
/dev:fix <error>        # Debug and fix bugs
/dev:fix-fast <error>   # Quick bug fix (tests optional)
/dev:fix-hard <error>   # Complex bug (deep analysis)
/dev:test <scope>       # Generate tests
/dev:tdd <feature>      # Test-driven development
/dev:review [file]      # Code review

Testing Options (available on most dev commands):

/dev:feature "login" --no-test           # Skip test enforcement
/dev:fix "bug" --test-level strict       # Override enforcement level
/dev:feature-tested "auth" --coverage 90 # Custom coverage target
/dev:fix-fast "typo" --with-test         # Opt-in to testing

Planning (`/planning:*`)

/planning:plan <task>        # Create implementation plan
/planning:plan-detailed      # Detailed plan (2-5 min tasks)
/planning:brainstorm <topic> # Interactive brainstorming
/planning:research <topic>   # Research technology
/planning:doc <target>       # Generate documentation

Git (`/git:*`)

/git:commit [message]   # Smart commit with conventional format
/git:ship [message]     # Commit + PR in one command
/git:pr [title]         # Create pull request
/git:deploy [env]       # Deploy to environment

Quality (`/quality:*`)

/quality:security-scan   # Scan for vulnerabilities
/quality:refactor <file> # Improve code structure
/quality:optimize <file> # Performance optimization
/quality:lint            # Run linting
/quality:verify-done     # Verify test requirements before completion
/quality:coverage-check  # Check coverage against gates
/quality:test-plan       # Generate comprehensive test plan

Omega (`/omega:*`)

/omega:10x <topic>      # Find 10x improvement path
/omega:100x <topic>     # Find 100x paradigm shift
/omega:1000x <topic>    # Find 1000x moonshot opportunity
/omega:principles       # Display 7 Omega Principles
/omega:dimensions       # Display 10 Omega Dimensions

Sprint Management (`/sprint:*`)

/sprint:vision-set      # Set product vision
/sprint:vision-show     # Display current vision
/sprint:sprint-new      # Create new sprint
/sprint:sprint-start    # Start current sprint
/sprint:sprint-current  # Show sprint progress
/sprint:sprint-end      # End sprint + retrospective
/sprint:ship            # Complete sprint + commit + push + PR
/sprint:backlog-add     # Add task to backlog
/sprint:backlog-show    # Display backlog
/sprint:team-run        # Run AI team
/sprint:team-status     # Show team activity

Reference-Aware Planning (available on sprint commands):

/sprint:sprint-new "Auth" --ref=artifacts/prd.md     # Sprint with PRD context
/sprint:team-run --ref=specs/api.yaml                # Add refs during execution
/sprint:backlog-add "Login" --ref=artifacts/prd.md   # Task with ref context

Sprint Ship (complete sprint + deploy):

/sprint:ship "Sprint 1 - MVP"     # Ship with message
/sprint:ship --skip-tests         # Skip tests (not recommended)
/sprint:ship --no-pr              # Push directly without PR
/sprint:ship --force              # Ship with incomplete tasks

Autonomous Development (`/auto:*`)

/auto:init <idea>       # Start discovery for new project
/auto:start             # Begin/continue autonomous execution
/auto:status            # Check project progress
/auto:approve           # Approve checkpoint to continue
/auto:reject            # Request changes with feedback
/auto:resume            # Resume from saved state

Alignment (`/alignment:*`)

/alignment:health       # Check system alignment health
/alignment:deps <type:name>  # Show dependency graph

ML Systems (New - 31 commands)

`/omgml:*` - Project Management

/omgml:init             # Initialize ML project structure
/omgml:status           # Show ML project status

`/omgdata:*` - Data Engineering

/omgdata:collect        # Collect data from sources
/omgdata:validate       # Validate data quality
/omgdata:clean          # Clean and preprocess data
/omgdata:split          # Split train/val/test
/omgdata:version        # Version datasets with DVC

`/omgfeature:*` - Feature Engineering

/omgfeature:extract     # Extract features from raw data
/omgfeature:select      # Select important features
/omgfeature:store       # Store in feature store

`/omgtrain:*` - Model Training

/omgtrain:baseline      # Create baseline models
/omgtrain:train         # Train model with config
/omgtrain:tune          # Hyperparameter tuning
/omgtrain:evaluate      # Evaluate model performance
/omgtrain:compare       # Compare model versions

`/omgoptim:*` - Model Optimization

/omgoptim:quantize      # Quantize to INT8/FP16
/omgoptim:prune         # Prune model weights
/omgoptim:distill       # Knowledge distillation
/omgoptim:profile       # Profile latency/memory

`/omgdeploy:*` - Deployment

/omgdeploy:package      # Package model for deployment
/omgdeploy:serve        # Deploy model serving
/omgdeploy:edge         # Deploy to edge devices
/omgdeploy:cloud        # Deploy to cloud platforms
/omgdeploy:ab           # Setup A/B testing

`/omgops:*` - ML Operations

/omgops:pipeline        # Create ML pipeline
/omgops:monitor         # Setup monitoring
/omgops:drift           # Detect data/model drift
/omgops:retrain         # Trigger retraining
/omgops:registry        # Manage model registry

Workflows (69)

Workflows are orchestrated sequences of agents, commands, and skills.

Development

Workflow	Description
`development/feature`	Complete feature from planning to PR
`development/bug-fix`	Systematic debugging and resolution
`development/refactor`	Code improvement and restructuring
`development/code-review`	Comprehensive code review

Testing Automation (New)

Workflow	Description
`testing/automated-testing`	End-to-end testing automation with task generation, enforcement, and coverage gates

AI Engineering

Workflow	Description
`ai-engineering/rag-development`	Build complete RAG systems
`ai-engineering/model-evaluation`	AI model evaluation pipeline
`ai-engineering/prompt-engineering`	Systematic prompt optimization
`ai-engineering/agent-development`	Build AI agents
`ai-engineering/fine-tuning`	Model fine-tuning workflow

AI-ML Operations

Workflow	Description
`ai-ml/data-pipeline`	Build ML data pipelines
`ai-ml/experiment-cycle`	ML experiment tracking
`ai-ml/model-deployment`	Model serving and deployment
`ai-ml/monitoring-setup`	ML model monitoring

Microservices

Workflow	Description
`microservices/domain-decomposition`	DDD bounded context analysis
`microservices/service-scaffolding`	Service template generation
`microservices/contract-first`	API contract development
`microservices/distributed-tracing`	Tracing implementation

Event-Driven

Workflow	Description
`event-driven/event-storming`	Domain event modeling
`event-driven/saga-implementation`	Distributed transaction patterns
`event-driven/schema-evolution`	Event schema management

Game Development

Workflow	Description
`game/prototype-to-production`	Game development lifecycle
`game/content-pipeline`	Asset management
`game/playtesting`	Testing and balancing

Omega

Workflow	Description
`omega/10x-improvement`	Tactical enhancements
`omega/100x-architecture`	System redesign
`omega/1000x-innovation`	Industry transformation

ML Systems (New - 12 workflows)

Workflow	Description
`ml-systems/full-ml-lifecycle-workflow`	Complete ML lifecycle orchestration
`ml-systems/data-pipeline-workflow`	Data collection to feature store
`ml-systems/model-development-workflow`	Baseline to optimized models
`ml-systems/model-optimization-workflow`	Quantization, pruning, distillation
`ml-systems/production-deployment-workflow`	Model packaging to serving
`ml-systems/mlops-pipeline-workflow`	CI/CD for ML systems
`ml-systems/model-monitoring-workflow`	Drift detection and alerting
`ml-systems/experiment-tracking-workflow`	Systematic experimentation
`ml-systems/feature-engineering-workflow`	Feature extraction and selection
`ml-systems/model-retraining-workflow`	Automated retraining triggers
`ml-systems/edge-deployment-workflow`	Edge/mobile model deployment
`ml-systems/ab-testing-workflow`	A/B testing for models

Skills (162)

Skills are domain expertise modules organized in 24 categories.

AI Engineering (12 skills)

Based on production AI application patterns:

Skill	Description
`ai-engineering/foundation-models`	Model architecture, sampling, structured outputs
`ai-engineering/evaluation-methodology`	AI-as-judge, semantic similarity, ELO ranking
`ai-engineering/prompt-engineering`	Few-shot, chain-of-thought, injection defense
`ai-engineering/rag-systems`	Chunking, embedding, hybrid retrieval, reranking
`ai-engineering/ai-agents`	Tool use, ReAct, Plan-and-Execute, memory
`ai-engineering/finetuning`	LoRA, QLoRA, PEFT, model merging
`ai-engineering/inference-optimization`	Quantization, batching, caching, vLLM
`ai-engineering/guardrails-safety`	Input/output guards, PII protection

ML Systems (18 skills - New)

Based on Chip Huyen's "Designing ML Systems" and Stanford CS 329S:

Skill	Description
`ml-systems/ml-systems-fundamentals`	Core ML concepts, design principles
`ml-systems/deep-learning-primer`	Neural network foundations
`ml-systems/dnn-architectures`	CNNs, RNNs, Transformers, hybrid models
`ml-systems/data-eng`	ML data pipelines, storage, processing
`ml-systems/training-data`	Sampling, labeling, augmentation
`ml-systems/feature-engineering`	Feature extraction, selection, stores
`ml-systems/ml-workflow`	Experiment design, model selection
`ml-systems/model-dev`	Training, evaluation, debugging
`ml-systems/ml-frameworks`	PyTorch, TensorFlow, scikit-learn
`ml-systems/efficient-ai`	Model compression, efficient architectures
`ml-systems/model-optimization`	Quantization, pruning, distillation
`ml-systems/ai-accelerators`	GPU/TPU optimization, hardware selection
`ml-systems/model-deployment`	Serving, containerization, scaling
`ml-systems/ml-serving-optimization`	Batching, caching, latency reduction
`ml-systems/edge-deployment`	TFLite, Core ML, TensorRT
`ml-systems/mlops`	CI/CD for ML, model registry, pipelines
`ml-systems/robust-ai`	Reliability, monitoring, drift detection
`ml-systems/deployment-paradigms`	Batch vs real-time vs streaming

Methodology (19 skills)

Skill	Description
`methodology/writing-plans`	Implementation plan creation
`methodology/executing-plans`	Plan execution best practices
`methodology/debugging`	Systematic debugging approach
`methodology/code-review`	Review standards and checklists
`methodology/tdd`	Test-driven development
`methodology/test-task-generation`	Auto-generate test tasks from features
`methodology/test-enforcement`	Enforce tests before task completion

Frameworks (10 skills)

Skill	Description
`frameworks/react`	React hooks, TypeScript, state management
`frameworks/nextjs`	App Router, Server Components, API routes
`frameworks/django`	DRF, ORM optimization, Celery tasks
`frameworks/fastapi`	Async/await, Pydantic v2, dependency injection
`frameworks/nestjs`	TypeScript, dependency injection, microservices

BigTech Workflow Alignment (4 skills - New)

Skills aligning OMGKIT with Google, Meta, Netflix, and Amazon engineering practices:

Skill	Description	BigTech Reference
`devops/feature-flags`	Progressive delivery, canary releases, A/B testing	Netflix, LaunchDarkly
`testing/chaos-engineering`	Fault injection, game days, resilience testing	Netflix Chaos Monkey
`devops/dora-metrics`	Deployment frequency, lead time, MTTR tracking	Google DORA Research
`methodology/stacked-diffs`	Stacked PRs for parallel code review	Meta Engineering

Other Categories

Category	Skills	Focus
AI-ML Operations	6	MLOps, feature stores, model serving
ML Systems	18	Production ML from data to deployment
Microservices	6	Service mesh, API gateway, tracing
Event-Driven	6	Kafka, event sourcing, CQRS
Game Development	5	Unity, Godot, networking
Databases	9	PostgreSQL, MongoDB, Redis
Frontend	7	Tailwind, shadcn/ui, accessibility
DevOps	9	Docker, Kubernetes, GitHub Actions, DORA, Feature Flags
Testing	10	Comprehensive, chaos, mutation, security
Security	4	OWASP, OAuth, hardening

Modes (10)

Modes configure Claude's behavior for different contexts.

Mode	Description
`default`	Balanced standard behavior
`tutor`	Teaching mode with Feynman technique & Socratic questions
`brainstorm`	Creative exploration, divergent thinking
`token-efficient`	Compressed output (30-70% savings)
`deep-research`	Thorough analysis with citations
`implementation`	Code-focused, minimal prose
`review`	Critical analysis mode
`orchestration`	Multi-task coordination
`omega`	10x-1000x thinking mode
`autonomous`	AI team self-management

Switch modes:

/context:mode <name>

Autonomous Development (14 Archetypes)

Build complete applications from idea to deployment.

Archetype	Description
SaaS MVP	Multi-tenant SaaS with auth, payments
API Service	Backend APIs for web/mobile apps
CLI Tool	Command-line utilities
Library/SDK	Reusable npm packages
Full-Stack App	Complete web applications
Mobile App	iOS/Android with React Native
AI-Powered App	LLM apps with RAG, function calling
AI Model Building	ML model training pipelines
Desktop App	Electron cross-platform apps
IoT App	Device management, real-time data
Game	Unity/Godot game development
Simulation	Scientific/engineering simulations
Microservices	Distributed services with K8s
Event-Driven	Async systems with Kafka, CQRS

How It Works

Discovery: AI asks questions to understand your vision
Planning: Generates architecture, tasks, and timeline
Execution: Autonomous development with checkpoints
Review: Human approval at critical milestones
Iteration: Feedback loop for refinements

Artifacts System

Provide project context with reference documents:

.omgkit/artifacts/
├── README.md   # How to use artifacts
├── data/       # Sample data, schemas, data dictionaries
├── docs/       # Requirements, user stories, PRDs
├── knowledge/  # Glossary, business rules, domain knowledge
├── research/   # Competitor analysis, market research
├── assets/     # Reference images, templates, mockups
└── examples/   # Code samples, reference implementations

Note: Artifacts are reference materials only, NOT execution instructions. They help AI understand your project context.

Project Structure

After omgkit init:

your-project/
├── .omgkit/
│   ├── config.yaml      # Project settings
│   ├── settings.json    # Permissions
│   ├── sprints/
│   │   ├── vision.yaml  # Product vision
│   │   └── backlog.yaml # Task backlog
│   ├── plans/           # Generated plans
│   ├── docs/            # Generated docs
│   ├── logs/            # Activity logs
│   ├── devlogs/         # Development logs (git-ignored)
│   │   └── README.md
│   ├── stdrules/        # Project standards
│   │   ├── README.md
│   │   ├── BEFORE_COMMIT.md
│   │   ├── SKILL_STANDARDS.md
│   │   └── TESTING_STANDARDS.md
│   └── artifacts/       # Project context (reference only)
│       └── README.md
├── OMEGA.md             # Project context file
└── CLAUDE.md            # Claude Code instructions

MCP Integrations

OMGKIT supports these MCP servers:

Server	Purpose
`context7`	Up-to-date library documentation
`sequential-thinking`	Multi-step reasoning
`memory`	Persistent knowledge graph
`filesystem`	Secure file operations
`playwright`	Browser automation

Standards & Rules

OMGKIT provides two types of standards:

For OMGKIT Contributors

Located in plugin/stdrules/:

File	Purpose
`ALIGNMENT_PRINCIPLE.md`	Component hierarchy rules
`OMGKIT_BEFORE_COMMIT_RULES.md`	Validation requirements
`SKILL_STANDARDS.md`	Skill documentation standards

For Project Developers

Generated in .omgkit/stdrules/ when you run omgkit init:

File	Purpose
`BEFORE_COMMIT.md`	Pre-commit checklist
`SKILL_STANDARDS.md`	Custom skill guidelines

CLI Commands

Global Commands

omgkit install      # Install plugin to Claude Code
omgkit init         # Initialize .omgkit/ in project
omgkit doctor       # Check installation status
omgkit list         # List all components
omgkit update       # Update plugin
omgkit uninstall    # Remove plugin
omgkit help         # Show help

Project Upgrade Commands (New)

Keep your project up-to-date with the latest OMGKIT features:

omgkit project:upgrade     # Upgrade project to latest OMGKIT version
omgkit project:upgrade --dry  # Preview changes without applying
omgkit project:rollback    # Rollback to previous backup
omgkit project:backups     # List available backups
omgkit project:version     # Show project's OMGKIT version

Safe Upgrade System

OMGKIT's upgrade system is designed with safety first:

Feature	Description
Version Tracking	Each project tracks its OMGKIT version in settings.json
Smart Merge	workflow.yaml uses add-only merge (never overwrites your values)
Protected Files	config.yaml, sprints/, artifacts/, devlogs/* are NEVER modified
Auto-Backup	Creates timestamped backup before any changes
Dry Run	Preview all changes with `--dry` flag before applying
Rollback	One command to restore previous state if needed

What Gets Upgraded

File Type	Upgrade Behavior
stdrules/	New standards are added, modified ones offer 3-way merge
workflow.yaml	Smart merge adds new sections, preserves your customizations
CLAUDE.md	Updated with new instructions
settings.json	Version updated, structure preserved
Your files	NEVER touched (config.yaml, sprints, artifacts, devlogs)

Config Commands (New)

Configure workflow settings via CLI:

# Get a config value
omgkit config get testing.enforcement.level
omgkit config get testing.coverage_gates.unit

# Set a config value
omgkit config set testing.enforcement.level strict
omgkit config set testing.auto_generate_tasks true
omgkit config set testing.coverage_gates.unit.minimum 90

# List all config or specific section
omgkit config list
omgkit config list testing

# Reset to default value
omgkit config reset testing.enforcement.level

Supported Value Types

Type	Example
String	`omgkit config set git.main_branch develop`
Boolean	`omgkit config set testing.auto_generate_tasks true`
Number	`omgkit config set testing.coverage_gates.unit.minimum 90`

Note: For arrays, edit .omgkit/workflow.yaml directly.

Documentation Sync Automation

OMGKIT uses a self-healing documentation system that ensures docs are always synchronized with code:

How It Works

Code is Single Source of Truth: All component metadata lives in plugin files
Auto-Discovery: Categories and counts are discovered dynamically, not hardcoded
Auto-Generation: mint.json navigation is generated from docs structure
Validation Tests: 23 tests verify docs-plugin sync before every release

Documentation Commands

npm run docs:generate   # Generate docs from plugin source
npm run docs:mint       # Generate mint.json navigation
npm run docs:validate   # Run docs sync validation tests
npm run docs:sync       # Generate + validate (recommended)

Pre-Release Protection

The preversion hook automatically runs docs:sync before version bumps:

npm version patch       # Runs docs:sync automatically

If any sync issue is detected (missing pages, wrong counts, broken links), the version bump fails.

Validation & Testing

OMGKIT has 8200+ automated tests ensuring system integrity.

Run Tests

npm test                           # All tests
npm test -- tests/validation/      # Validation tests only
npm test -- tests/unit/            # Unit tests only
npm run test:docs                  # Documentation sync tests

Test Categories

Category	Tests	Purpose
Registry Sync	~200	Verify registry matches files
Alignment	~400	Component hierarchy validation
Documentation	~500	Quality and format checks
Docs Sync	23	Plugin-to-docs mapping validation
Format	~300	Naming convention compliance
Dependency Graph	~600	Reference integrity

Contributing

See CONTRIBUTING.md for guidelines.

Quick Start

Fork and clone the repository
Install dependencies: npm install
Run tests: npm test
Make changes following plugin/stdrules/
Submit PR with conventional commit messages

Documentation

Full documentation available at: omgkit.mintlify.app

License

MIT - See LICENSE for details.

Think Omega. Build Omega. Be Omega.

Keywords

FAQs

What is omgkit?

Is omgkit popular?

Is omgkit well maintained?

Package last updated on 08 Jan 2026

Did you know?

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.

Install

omgkit

OMGKIT - Omega-Level Development Kit

What is OMGKIT?

The Vision

Key Numbers

Core Concepts

1. Optimized Alignment Principle (OAP)

2. Omega Philosophy

3. Sprint Management

4. Reference-Aware Planning (New)

5. Testing Automation

Auto-Generate Test Tasks

Enforce Tests Before Done

Coverage Gates

6. Design System

V2 Theme Features

5 Theme Categories

Design Commands

Theme Export

Theme Rebuild

Generated CSS Variables

How It Works

Installation

Prerequisites

Install OMGKIT

Verify Installation

Quick Start

Agents (41)

Core Development

Operations

Architecture & Platform

Security

Data & ML

ML Systems (New)

Specialized Domains

Omega Exclusive

Commands (174)

Development (/dev:*)

Planning (/planning:*)

Git (/git:*)

Quality (/quality:*)

Omega (/omega:*)

Sprint Management (/sprint:*)

Autonomous Development (/auto:*)

Alignment (/alignment:*)

ML Systems (New - 31 commands)

/omgml:* - Project Management

/omgdata:* - Data Engineering

/omgfeature:* - Feature Engineering

/omgtrain:* - Model Training

/omgoptim:* - Model Optimization

/omgdeploy:* - Deployment

/omgops:* - ML Operations

Workflows (69)

Development

Testing Automation (New)

AI Engineering

AI-ML Operations

Microservices

Event-Driven

Game Development

Omega

ML Systems (New - 12 workflows)

Skills (162)

AI Engineering (12 skills)

ML Systems (18 skills - New)

Methodology (19 skills)

Frameworks (10 skills)

BigTech Workflow Alignment (4 skills - New)

Other Categories

Modes (10)

Autonomous Development (14 Archetypes)

How It Works

Artifacts System

Project Structure

MCP Integrations

Standards & Rules

For OMGKIT Contributors

For Project Developers

CLI Commands

Development (`/dev:*`)

Planning (`/planning:*`)

Git (`/git:*`)

Quality (`/quality:*`)

Omega (`/omega:*`)

Sprint Management (`/sprint:*`)

Autonomous Development (`/auto:*`)

Alignment (`/alignment:*`)

`/omgml:*` - Project Management

`/omgdata:*` - Data Engineering

`/omgfeature:*` - Feature Engineering

`/omgtrain:*` - Model Training

`/omgoptim:*` - Model Optimization

`/omgdeploy:*` - Deployment

`/omgops:*` - ML Operations