🧿 DotAI Boiler

A sophisticated framework for AI-assisted development workflows

DotAI Boiler transforms your development workflow by creating a structured knowledge ecosystem that evolves with your project, ensuring AI assistants maintain deep context across sessions while enforcing consistent implementation patterns. This sophisticated framework bridges the gap between human creativity and machine precision, dramatically reducing cognitive overhead and technical debt through its comprehensive Codex system, session management tools, and standardized blueprints that adapt to your specific project requirements.

Features • Installation • Usage • Architecture • Advanced Features • Contributing • License

📋 Table of Contents

• 🤖 DotAI Boiler
  • 📋 Table of Contents
  • ✨ Features
  • 🚀 Installation
    • Prerequisites
    • Basic Installation
    • Advanced Installation Options
  • 📚 Usage
    • AI Codex
    • Session Management
    • Blueprints
    • Quick Start Guide
  • 🏗️ Architecture
  • 🔧 Advanced Features
    • Model Context Protocol (MCP)
    • AI Plugins
    • Integration Capabilities
  • 🛠️ Customization
    • Creating Custom Rules
    • Extending Blueprints
  • 👥 Contributing
  • 📝 License
  • 🙏 Acknowledgements
  • 📊 Project Status

✨ Features

• 💡 AI Codex System: Repository of learnings and errors to improve code quality over time
• 🤝 AI Assistant Integration: Seamless workflow with Ai/LLMs like GitHub Copilot, Claude, and ChatGPT
• 💾 Session Management: Maintain project context across multiple interactions with persistent memory
• 🗺️ Blueprints: Comprehensive guides for implementing specific technical architectures
• 📝 Snippets: Code templates for consistent implementation patterns across your project
• 📏 MCP Rules: Specialized rules for AI interactions with different technologies
• 📚 Version Controlled AI Memory: Track and manage AI learning across your project lifecycle
• 🔄 Workflow Automation: Streamline repetitive tasks with AI-powered scripts
• 🧩 Plugin System: Extend functionality with custom plugins and integrations

🚀 Installation

Prerequisites

• Git installed on your system
• An AI assistant of your choice (Cursor Editor, GitHub Copilot, etc.)

Basic Installation

# Clone the repository
git clone https://github.com/helloprkr/dotai_boiler.git

# Navigate to the project directory
cd dotai_boiler

# Initialize your project
# Copy configuration files to your project root or use as a reference
cp -r .ai/ /path/to/your/project/

Advanced Installation Options

For advanced users who want to customize their installation:

# Install with specific blueprints only
cp -r .ai/blueprints/supabase-drizzle/ /path/to/your/project/.ai/blueprints/

# Install as a Git submodule for easier updates
git submodule add https://github.com/helloprkr/dotai_boiler.git .ai

📚 Usage

AI Codex

The Codex system maintains a repository of learnings and errors to improve code quality:

# Review the Codex
cat .ai/codex/codex.md

# Add a new learning to the Codex
echo "# Learning: Optimizing React re-renders \n\n..." > .ai/codex/learn-react-optimization.md

# Reference the Codex in your commits
git commit -m "fix: Apply Codex learning on React optimization (ref: learn-react-optimization.md)"

Session Management

Create a "memory layer" for AI across multiple interactions:

# Start a new AI session
echo "# Session: Implementing authentication \n\n..." > .ai/session/auth-implementation.md

# Update the session with new information
echo "## Database schema \n\n..." >> .ai/session/auth-implementation.md

# Reference the session when working with your AI assistant
# @import .ai/session/auth-implementation.md

Blueprints

Implement specific technical architectures with step-by-step guides:

• Supabase + Drizzle + Server Actions: Comprehensive backend architecture

  # View the blueprint
  cat .ai/blueprints/supabase-drizzle/README.md
  
  # Follow implementation steps
  cat .ai/blueprints/supabase-drizzle/01-setup.md

• Flux + Replicate: Image generation workflow

  # View the blueprint
  cat .ai/blueprints/flux-replicate/README.md

• Model Context Protocol (MCP): Optimized AI interactions

  # View the MCP documentation
  cat .ai/rules/mcp/README.md

Quick Start Guide

1. Initialize DotAI Boiler in your project
2. Create a session file for your current task
3. Reference appropriate blueprints for implementation
4. Use snippets for consistent code patterns
5. Document learnings in the Codex for future reference

🏗️ Architecture

.
├── .ai/                  # AI-assisted development tools
│   ├── actions/          # Automated actions for AI workflows
│   ├── blueprints/       # Architecture implementation guides
│   │   ├── supabase-drizzle/    # Supabase backend architecture
│   │   ├── flux-replicate/      # Image generation workflow
│   │   └── nextjs-complete/     # Full-stack Next.js architecture
│   ├── codex/            # Repository of AI learnings and errors
│   │   ├── codex.md      # Main codex document
│   │   ├── learn.md      # Template for new learnings
│   │   └── errors/       # Documented error patterns
│   ├── components/       # Reusable UI/UX components
│   ├── lib/              # Library documentation and examples
│   │   ├── react/        # React-specific libraries
│   │   └── node/         # Node.js utilities
│   ├── plugins/          # Integration with external AI tools
│   │   ├── v0/           # v0.dev integration
│   │   └── replicate/    # Replicate models integration
│   ├── rules/            # Rules for AI behavior
│   │   ├── mcp/          # Model Context Protocol rules
│   │   ├── typescript/   # TypeScript-specific rules
│   │   └── nextjs/       # Next.js framework rules
│   ├── scripts/          # Automation scripts
│   │   ├── session.sh    # Session management utilities
│   │   └── codex.sh      # Codex management utilities
│   ├── session/          # Session management tools
│   │   ├── start-session.md  # Start session template
│   │   ├── end-session.md    # End session template
│   │   └── template.md   # Session template
│   ├── snippets/         # Code templates
│   │   ├── react/        # React component templates
│   │   ├── nextjs/       # Next.js templates
│   │   └── typescript/   # TypeScript utility templates
│   └── status/           # Session status tracking
├── .cursor/              # Cursor editor configuration
│   └── rules/            # MCP rules for the Cursor editor
│       ├── go.mcp        # Go language rules
│       ├── docker.mcp    # Docker containerization rules
│       └── dagger.mcp    # Dagger CI/CD rules
└── README.md             # Project documentation

🔧 Advanced Features

Model Context Protocol (MCP)

The Model Context Protocol provides specialized rules for AI interactions with different technologies:

• Cursor MCP Rules: Optimized for Go, Dagger, and Docker development

  // Example Go MCP rule
  @rule go_error_handling {
    context: "error handling pattern in Go",
    pattern: "if err != nil { return nil, err }",
    explanation: "Standard Go error handling pattern"
  }
  

• Docker MCP Rules: Best practices for Docker containerization

  // Example Docker MCP rule
  @rule docker_multistage {
    context: "multi-stage Docker builds",
    pattern: "FROM ... AS builder\n...\nFROM ...\nCOPY --from=builder",
    explanation: "Use multi-stage builds to reduce image size"
  }
  

AI Plugins

• v0.dev Integration: Generate React components from screenshots and natural language

  # Generate a component from description
  cat .ai/plugins/v0/examples/navbar.md | curl -X POST https://v0.dev/api/generate

• Replicate Models Integration: Access specialized AI models for various tasks

  # Use Replicate for image generation
  source .ai/plugins/replicate/setup.sh
  replicate-run stability-ai/sdxl "A futuristic city with flying cars"

Integration Capabilities

• GitHub Actions: Automate workflows with AI-enhanced GitHub Actions
• Hugging Face: Connect to specialized AI models for domain-specific tasks
• LangChain: Build advanced AI applications with the LangChain framework

🛠️ Customization

Creating Custom Rules

You can create custom MCP rules for your specific technology stack:

1. Create a new rule file in .ai/rules/custom/
2. Define your rules using the MCP syntax
3. Reference your rules in your AI sessions

Example custom rule:

// .ai/rules/custom/my-framework.mcp
@rule my_framework_pattern {
  context: "recommended pattern for MyFramework",
  pattern: "...",
  explanation: "..."
}

Extending Blueprints

Create custom blueprints for your organization's preferred architectures:

1. Create a new directory in .ai/blueprints/
2. Add README.md with overview and purpose
3. Create step-by-step implementation guides
4. Include code examples and configuration templates

👥 Contributing

We welcome contributions to improve the DotAI Boiler framework! See CONTRIBUTING.md for details.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request
6. Add a changelog entry with your contribution

📝 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgements

• Cursor - The AI-native code editor
• OpenAI - For advancements in AI assistance
• Anthropic - For Claude's helpful capabilities
• All contributors who have helped shape this framework

📊 Project Status

DotAI Boiler is in active development. We're constantly improving the framework based on real-world usage and feedback. Check the GitHub repository for the latest updates.

Current version: 0.6.0-beta

---

DotAI Boiler — Elevating development workflows with artificial intelligence

⭐ Star us on GitHub