VDK Docs
Blueprints

Core Concepts

Understanding the fundamental concepts of VDK Blueprints and AI rules system

Core Concepts

Understanding the fundamental concepts behind VDK Blueprints will help you effectively use and contribute to the AI rules system.

What are AI Rules?

AI Rules (also called Blueprints) are structured instructions that guide AI coding assistants to follow specific patterns, practices, and behaviors when working on your code. They're written in .mdc (Markdown with metadata) format and contain:

  • Metadata: Platform compatibility, dependencies, and configuration
  • Instructions: Specific guidance for the AI assistant
  • Examples: Code samples and use cases
  • Context: When and how to apply the rules

Rule Categories

VDK Blueprints organizes rules into six main categories:

1. Core Rules (4 rules)

Fundamental AI behavior patterns that apply to all development:

  • Agent Behavior: Core AI assistant persona and principles
  • Code Quality: Universal code quality guidelines
  • Security Practices: Security best practices
  • Error Prevention: Common error prevention patterns

2. Language Rules (6 rules)

Programming language-specific guidelines:

  • TypeScript Modern: Modern TypeScript patterns
  • TypeScript 5: TypeScript 5 specific features
  • Python 3: Python 3 best practices
  • Swift: Swift development guidelines
  • C++20: Modern C++ standards
  • Kotlin: Kotlin development patterns

3. Technology Rules (26 rules)

Framework and tool-specific patterns:

  • React 19: Modern React development
  • Next.js: Next.js best practices
  • Supabase: Database and auth integration
  • Tailwind 4: Utility-first CSS
  • And 22 more technologies...

4. Stack Rules (6 rules)

Multi-technology combinations:

  • Next.js + Supabase: Full-stack web development
  • React Native Mobile: Cross-platform mobile development
  • TRPC Full-Stack: End-to-end type safety
  • Astro Content: Content-focused sites
  • E-commerce: Online store patterns
  • Next.js Enterprise: Large-scale applications

5. Task Rules (54 rules)

Executable development workflows:

  • AI Code Review: Automated code review processes
  • Security Audit: Security assessment workflows
  • Performance Optimization: Performance improvement patterns
  • And 51 more development tasks...

6. Assistant Rules (7 rules)

AI platform-specific configurations:

  • Claude: Claude-specific optimizations
  • Cursor: Cursor integration patterns
  • Windsurf: Windsurf workflows
  • GitHub Copilot: Copilot configurations
  • VS Code: VS Code optimizations
  • JetBrains: JetBrains IDE integration
  • Zed: Zed editor patterns

Metadata System

Each rule contains structured metadata in YAML frontmatter:

---
# Core Identification
id: "react19"
title: "React 19 Best Practices"
description: "React best practices for modern web applications"
version: "2.0.0"
lastUpdated: "2025-07-25"

# Categorization
category: "technology"
subcategory: "framework"
complexity: "medium"
scope: "project"
audience: "developer"
maturity: "stable"

# Platform Compatibility
platforms:
  claude-code:
    compatible: true
    memory: true
    allowedTools: ["Read", "Write", "Edit"]
  cursor:
    compatible: true
    globs: ["**/*.tsx", "**/*.jsx"]
    priority: "high"

# Dependencies
requires: []
suggests: ["typescript-modern", "tailwind4"]
conflicts: []
---

Platform Compatibility

Rules are designed to work across multiple AI assistant platforms:

Claude Code

  • Memory Integration: Rules loaded into assistant memory
  • Tool Access: Specific tools allowed per rule
  • Namespace: Project-scoped or global
  • MCP Integration: Support for Model Context Protocol

Cursor

  • Auto-attachment: Rules automatically applied to matching files
  • Glob Patterns: File pattern matching for rule activation
  • Priority System: High/medium/low priority rules
  • Real-time: Continuous assistance during coding

Windsurf

  • Workspace Mode: Rules applied to entire workspace
  • XML Tags: Structured rule organization
  • Character Limits: Optimized for memory constraints
  • Context Awareness: Smart rule activation

GitHub Copilot

  • Review Integration: Rules applied during code review
  • Priority Scoring: Numerical priority system (1-10)
  • Code Quality: Focus on maintainability and best practices

Rule Lifecycle

1. Development

  • Write rule using .mdc format
  • Define metadata and platform compatibility
  • Include examples and use cases
  • Test with target AI assistants

2. Validation

  • Schema validation against rule standards
  • Platform compatibility testing
  • Performance impact assessment
  • Community review process

3. Publication

  • Merge into main repository
  • Version tagging and changelog
  • Documentation updates
  • Community notification

4. Maintenance

  • Regular updates for new platform features
  • Performance optimizations
  • Bug fixes and improvements
  • Deprecation and retirement

Best Practices

Writing Effective Rules

  • Be Specific: Clear, actionable instructions
  • Include Context: When and why to apply the rule
  • Provide Examples: Code samples and use cases
  • Consider Compatibility: Test across all target platforms

Platform Optimization

  • Respect Limits: Consider memory and character constraints
  • Use Priorities: Set appropriate priority levels
  • Test Integration: Verify rule activation and behavior
  • Monitor Performance: Ensure rules don't slow down assistance

Community Contribution

  • Follow Templates: Use provided rule templates
  • Document Changes: Clear commit messages and changelog
  • Test Thoroughly: Verify across multiple scenarios
  • Engage Community: Discuss and gather feedback

Next Steps