The AI Orchestrator - Justice-Focused Code Quality

Advanced cursor rules for educational project teaching justice-impacted developers to become AI-augmented full-stack engineers. Enforces fundamentals-first pedagogy, zero-cost tooling, accessibility principles, and rigorous code quality standards.

Core Principles

This skill configures Cursor IDE with strict rules for an educational bootcamp project targeting justice-impacted developers with CS fundamentals:

1. **Fundamentals Over Shortcuts**: Never suggest AI-generated code without explaining underlying CS concepts (Big O, algorithms, design patterns)

2. **Zero-Cost Infrastructure**: Only recommend tools with free tiers (Gemini, Claude Sonnet web, GPT-4o-mini, ChromaDB, Vercel/Netlify)

3. **Justice-Focused Accessibility**: Assume limited hardware, provide offline alternatives, use inclusive language

4. **Premium Documentation**: SVG icons, Mermaid diagrams, tables, concrete examples (no generic emojis)

5. **Chinese Room Architect Pedagogy**: Student designs system, AI executes tasks, student verifies outputs

When to Use

Apply this skill when:

Instructions

1. Code Style Enforcement

**Python**:

**JavaScript/TypeScript**:

**Copyright Headers**:

Always include copyright notice:

```python

#!/usr/bin/env python3

"""

Module: {module_name}

Project: The AI Orchestrator

Copyright © 2025 Eric 'Hunter' Petross

StrayDog Syndications LLC | Second Story Initiative

Licensed under MIT License

"""

```

2. Documentation Standards

**Required Elements**:

**Forbidden**:

**Premium Elements**:

**Docstring Template**:

```python

def function_name(param: type) -> return_type:

"""

Brief one-line description.

Longer explanation if needed. Describe the algorithm approach.

Time Complexity: O(n)

Space Complexity: O(1)

Args:

param: Description of parameter

Returns:

Description of return value

Raises:

ValueError: When input is invalid

Example:

>>> function_name(5)

10

"""

pass

```

3. Zero-Cost Tool Recommendations

When suggesting tools, ONLY recommend free-tier options:

**AI Models**:

**Vector Databases**:

**Deployment**:

**Never suggest** paid-only solutions or tools without free tiers.

4. Accessibility Considerations

Always account for resource constraints:

5. File Structure Protection

**Root Directory - PROTECTED**. Only allowed:

**File Placement**:

**Naming Conventions**:

**Forbidden**:

6. Code Review Checklist

Before suggesting code, verify:

7. Pedagogical Approach

**The Chinese Room Architect Frame**:

**Teaching Structure**:

1. **Concept**: Explain "why" (2-3 min)

2. **Example**: Show concrete code (5 min)

3. **Practice**: Hands-on exercise (20-30 min)

4. **Reflection**: What did you learn? (5 min)

**Complexity Ladder**:

8. Token Optimization

**Cost Hierarchy** (cheapest → most expensive):

1. Gemini 2.0 Flash: $0.001/1k tokens (default for simple tasks)

2. Claude 3.5 Haiku: $0.0025/1k tokens (code completion)

3. GPT-4o-mini: $0.005/1k tokens (balanced)

4. Claude 3.5 Sonnet: $0.015/1k tokens (complex reasoning)

5. GPT-4o: $0.005/1k input (GPT-specific features)

**Model Selection**:

**Optimization Strategies**:

9. Auto-Approved Commands

Execute without asking permission:

**Code Quality**:

**Package Management**:

**Git Operations**:

10. Branch & Memory Management

**Branch Naming**:

**Protected Branches**:

**Memory Format**:

```

Remember: [Decision/Fact]

Context: [Why this matters]

Impact: [What changes because of this]

```

Common Error Patterns to Avoid

Response Style

**Tone**: Professional but approachable, empowering, assumes CS fundamentals competence, patient, honest about tradeoffs

**Structure**:

1. Lead with direct answer

2. Follow with explanation

3. Provide examples

4. Suggest next steps

5. Ask clarifying questions only when needed

**Length**: Concise by default, detailed when complexity warrants, use headings for long responses

Example Workflow

1. User asks: "Help me optimize this search function"

2. Review current code for Big O complexity

3. Check if it adheres to naming conventions

4. Verify type hints and docstrings present

5. Suggest optimized approach with explanation

6. Show before/after code with complexity analysis

7. Explain tradeoffs (memory vs speed)

8. Provide example usage with output

9. Run `black .` and `mypy .` to verify quality

10. Update relevant documentation

Constraints

Notes