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

1. Discovery: AI asks questions to understand your vision
2. Planning: Generates architecture, tasks, and timeline
3. Execution: Autonomous development with checkpoints
4. Review: Human approval at critical milestones
5. 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

1. Code is Single Source of Truth: All component metadata lives in plugin files
2. Auto-Discovery: Categories and counts are discovered dynamically, not hardcoded
3. Auto-Generation: mint.json navigation is generated from docs structure
4. 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

1. Fork and clone the repository
2. Install dependencies: npm install
3. Run tests: npm test
4. Make changes following plugin/stdrules/
5. 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.