Permanent Context: Your AI remembers your team structure, project details, and business metrics across every conversation

Dynamic Intelligence: Variables that compute, update, and adapt as your business evolves

Team Consistency: Everyone works with the same accurate, up-to-date information

Token Efficiency: 85-95% reduction in context-setting overhead

Human: “Can Sarah take on the payment integration?”
AI: “I need more context. Who is Sarah and what’s her role?”
Human: “Sarah Chen, our Frontend Lead”
AI: “What’s her current workload?”
Human: “She’s on the dashboard project for Sprint 14”
AI: “What are her technical skills?”
Human: “React, TypeScript, some payment gateway experience…”
[Token count: ~150 just for context]

Human: “Can Sarah take on the payment integration?”
AI: [Knows Sarah is Frontend Lead with React/TypeScript skills]
[Knows current sprint goals include dashboard launch]
[Can evaluate based on actual data]“Sarah has the technical skills for payment integration, but she’s leading the dashboard launch this sprint. Consider assigning it to her for Sprint 15, or bring in Mark who has Stripe experience and lighter Sprint 14 commitments.”
[Token count: ~25 – an 83% reduction]

The Key Insight:

Data Types create the language. Variables speak it fluently.

1. REUSABILITY: Define once, use infinitely

2. CONSISTENCY: Single source of truth across all interactions

3. EFFICIENCY: Dramatic reduction in token usage

Prompt 1: “Our development server is at dev.taskmaster.io with staging at…”
Prompt 5: “Deploy to our dev server (which is dev.taskmaster.io)…”
Prompt 12: “Check the dev environment at dev.taskmaster.io…”
[Endless rewriting]

# Define once in PROJECT_VARIABLES
ENVIRONMENTS = {
    "dev": "dev.taskmaster.io",
    "staging": "staging.taskmaster.io",
    "prod": "app.taskmaster.io"
}

# Reference anywhere
"Deploy to ENVIRONMENTS.dev"
"Check ENVIRONMENTS.staging"
"Monitor ENVIRONMENTS.prod"

The variable persists across sessions, team members, and time. Define it in January, still using it in December.

Monday: “Our sprint ends July 29th”
Wednesday: “We have until July 30th for the sprint”
Friday: “Sprint closes on the 29th”Which is correct? The AI doesn’t know, and neither does your team.

CURRENT_SPRINT.end_date = "2025-07-29"

Every reference points to the same value. Update it once, everyone sees the change. No conflicts, no confusion.

# Instead of explaining project context every time:
PROJECT_CONTEXT = {
    "name": "TaskMaster Pro",
    "version": "2.0",
    "team_size": 12,
    "current_phase": "Beta Testing",
    "key_metrics": {
        "active_users": 45000,
        "daily_growth": "3.2%",
        "churn_rate": "2.1%"
    },
    "tech_stack": ["React", "Node.js", "PostgreSQL", "Redis"],
    "deployment": "AWS ECS with CloudFront"
}

# One reference replaces ~100 tokens of explanation
"Given PROJECT_CONTEXT, analyze our scaling needs"

Result: 95% token reduction on complex context setting

Real-World Impact:

A team of 5 using CRAFT Variables saves ~2,000 tokens per day. That’s 60,000 tokens per month – equivalent to eliminating 40 hours of repetitive context-setting.

# 1. GLOBAL CONSTANTS (SCREAMING_SNAKE_CASE)
COMPANY_NAME = "InnovateTech Solutions"
MAX_RETRY_ATTEMPTS = 3
API_VERSION = "v2.5"

# 2. Configuration Variables (UPPER_SNAKE_CASE)
DEFAULT_TIMEZONE = "PST"
CACHE_DURATION = 3600
LOG_LEVEL = "INFO"

# 3. Namespace Variables (Namespace.VARIABLE_NAME)
Project.PHOENIX_LAUNCH = "2025-03-15"
Team.FRONTEND_LEAD = "Sarah Chen"
Budget.Q1_ALLOCATION = 125000

# 4. Active Variables (lower_snake_case)
current_sprint = 23
active_feature_flags = ["dark_mode", "new_dashboard"]
last_deployment = "2025-07-25"

# Without namespaces - confusion central
lead = "Sarah Chen"        # Which team's lead?
budget = 125000           # Which project's budget?
deadline = "2025-08-15"   # Deadline for what?

# With namespaces - crystal clarity
Team.FRONTEND_LEAD = "Sarah Chen"
Project.PHOENIX_BUDGET = 125000
Sprint.14_DEADLINE = "2025-08-15"

The Payoff:

A well-organized variable system is like a well-organized workspace. Everything has its place, finding what you need is instant, and scaling becomes natural rather than painful.

# Strings
COMPANY_MOTTO = "Innovation Through Simplicity"
SUPPORT_EMAIL = "help@taskmaster.io"

# Numbers
MAX_TEAM_SIZE = 25
TRIAL_PERIOD_DAYS = 30
BASE_PRICE = 49.99

# Booleans
IS_BETA_ACTIVE = True
MAINTENANCE_MODE = False

# Dates
FOUNDED_DATE = "2019-01-15"
FISCAL_YEAR_END = "2025-03-31"

Simple, static, essential. These form 60% of most CRAFT implementations.

# Lists for ordered data
DEPLOYMENT_STAGES = ["dev", "staging", "uat", "prod"]
PRIORITY_LEVELS = ["critical", "high", "medium", "low"]
TECH_STACK = ["Python", "React", "PostgreSQL", "Redis"]

# Dictionaries for related data
TEAM_ROLES = {
    "frontend": ["Sarah", "Alex"],
    "backend": ["Marcus", "Lisa"],
    "qa": ["Rita"],
    "devops": ["Chen"]
}

# Nested structures for complex relationships
PRODUCT_TIERS = {
    "starter": {
        "price": 49,
        "users": 5,
        "features": ["core", "basic_analytics"]
    },
    "professional": {
        "price": 149,
        "users": 25,
        "features": ["core", "advanced_analytics", "api_access"]
    }
}

Collections organize related data, making complex information manageable.

# Reference to current state
ACTIVE_SPRINT = Sprint.CURRENT
PROJECT_LEAD = Team.Members.SARAH
PRIMARY_DATABASE = Config.Databases.PROD

# Cross-references between systems
Sprint.CURRENT.team_lead = Team.Members.SARAH
Team.Members.SARAH.current_projects = [Project.PHOENIX, Project.FALCON]
Project.PHOENIX.assigned_team = Team.FRONTEND

References create a living network of relationships, automatically staying in sync.

DEPLOYMENT_STATE = {
    "current": "staging",
    "previous": "dev",
    "next": "uat",
    "history": [
        {"stage": "dev", "date": "2025-07-20", "status": "success"},
        {"stage": "staging", "date": "2025-07-22", "status": "in_progress"}
    ],
    "allowed_transitions": {
        "dev": ["staging"],
        "staging": ["dev", "uat"],
        "uat": ["staging", "prod"],
        "prod": ["uat"]
    }
}

AI can now understand not just where you are, but where you can go and where you’ve been.

CONFIG = {
    "global": {
        "timeout": 30,
        "retry_attempts": 3,
        "log_level": "INFO"
    },
    "environments": {
        "dev": {
            "log_level": "DEBUG",  # Overrides global
            "api_url": "http://localhost:3000"
        },
        "prod": {
            "timeout": 60,  # Overrides global
            "api_url": "https://api.taskmaster.io"
        }
    }
}

Variables inherit and override, creating flexible configuration systems.

TEAM_METRICS = {
    "total_capacity": sum([member["weekly_hours"] for member in Team.Members]),
    "sprint_allocation": {
        member: tasks for member, tasks in Sprint.CURRENT.assignments
    },
    "utilization_rate": Sprint.CURRENT.allocated_hours / TEAM_METRICS.total_capacity,
    "availability": {
        member: capacity - allocated 
        for member, capacity, allocated in team_calculations()
    }
}

Variables that calculate themselves based on other variables create intelligent systems.

The Hidden Power:

Advanced variable patterns don’t just store information – they encode your business logic, making your AI assistant understand not just your data, but how your business actually works.

from datetime import datetime, timedelta

def get_current_week():
    """Return current week number and date range"""
    today = datetime.now()
    week_num = today.isocalendar()[1]
    week_start = today - timedelta(days=today.weekday())
    week_end = week_start + timedelta(days=6)
    
    return {
        "number": week_num,
        "start": week_start.strftime("%Y-%m-%d"),
        "end": week_end.strftime("%Y-%m-%d"),
        "days_remaining": 7 - today.weekday()
    }

CURRENT_WEEK = get_current_week()
# Always returns this week's actual data

def get_project_age():
    """Calculate how long project has been running"""
    start = datetime(2024, 6, 1)
    age = datetime.now() - start
    
    return {
        "days": age.days,
        "weeks": age.days // 7,
        "months": age.days // 30,
        "formatted": f"{age.days // 30}m {age.days % 30}d"
    }

PROJECT_AGE = get_project_age()
# Updates every time it's referenced

Never manually update dates again. Time-aware variables stay current automatically.

def calculate_team_metrics():
    """Aggregate team performance data"""
    team_data = Team.Members
    
    return {
        "total_members": len(team_data),
        "by_role": {
            role: len([m for m in team_data if m.role == role])
            for role in ["frontend", "backend", "qa", "devops"]
        },
        "capacity_hours": sum(m.weekly_hours for m in team_data),
        "utilized_hours": sum(m.assigned_hours for m in team_data),
        "utilization_rate": f"{(utilized_hours/capacity_hours)*100:.1f}%"
    }

TEAM_METRICS = calculate_team_metrics()

def get_budget_status():
    """Calculate current budget position"""
    allocated = sum(Budget.Projects.values())
    spent = sum(Expenses.Current.values())
    
    return {
        "total_budget": Budget.ANNUAL,
        "allocated": allocated,
        "spent": spent,
        "remaining": Budget.ANNUAL - allocated,
        "burn_rate": spent / datetime.now().month,
        "projected_year_end": (spent / datetime.now().month) * 12,
        "status": "on-track" if projected < allocated else "over-budget"
    }

BUDGET_STATUS = get_budget_status()

Aggregation variables turn scattered data into actionable insights instantly.

def get_deployment_readiness():
    """Evaluate if we're ready to deploy"""
    checks = {
        "tests_passing": Test.Results.LATEST.all_passed,
        "code_reviewed": PullRequest.CURRENT.approved,
        "staging_tested": Deployment.STAGING.last_test_date > PR.merge_date,
        "team_available": CURRENT_WEEK.days_remaining > 2,
        "no_blockers": len(Issues.CRITICAL) == 0
    }
    
    ready = all(checks.values())
    blockers = [k for k, v in checks.items() if not v]
    
    return {
        "ready": ready,
        "checks": checks,
        "blockers": blockers,
        "recommendation": "Deploy" if ready else f"Fix: {', '.join(blockers)}"
    }

DEPLOYMENT_READY = get_deployment_readiness()

def select_server_config():
    """Choose config based on current conditions"""
    if ENVIRONMENT == "production":
        if TRAFFIC.current > TRAFFIC.normal * 1.5:
            return Config.Servers.HIGH_LOAD
        else:
            return Config.Servers.STANDARD
    else:
        return Config.Servers.DEVELOPMENT

ACTIVE_CONFIG = select_server_config()

Conditional variables adapt to your current situation, providing context-aware recommendations.

PROJECT_HEALTH = {
    # Time Intelligence
    "schedule": {
        "days_until_launch": (LAUNCH_DATE - datetime.now()).days,
        "progress_percentage": COMPLETED_TASKS / TOTAL_TASKS * 100,
        "on_schedule": VELOCITY.current >= VELOCITY.required,
        "projected_completion": calculate_completion_date()
    },
    
    # Team Intelligence
    "team": {
        "availability": check_team_availability(),
        "workload_balance": calculate_workload_distribution(),
        "skill_gaps": identify_missing_skills(),
        "morale_indicator": aggregate_team_surveys()
    },
    
    # Technical Intelligence
    "technical": {
        "code_quality": {
            "coverage": Test.COVERAGE.percentage,
            "tech_debt": CodeAnalysis.DEBT_SCORE,
            "bug_trend": calculate_bug_trend()
        },
        "performance": {
            "response_time": Metrics.API.avg_response,
            "error_rate": Metrics.ERRORS.rate_per_hour,
            "uptime": Metrics.UPTIME.last_30_days
        }
    },
    
    # Overall Health Score
    "health_score": calculate_weighted_health_score(),
    "status": determine_project_status(),
    "recommendations": generate_recommendations()
}

One variable reference gives the AI complete project context. Ask “How’s the project?” and get intelligent analysis.

# Don't compute until needed
@lazy_compute
def EXPENSIVE_METRICS():
    return analyze_all_customer_data()

# Only runs when explicitly referenced

# Compute once per session
@cache_for_session
def QUARTERLY_REPORT():
    return generate_comprehensive_report()

# Refreshes only when explicitly cleared

# Updates when dependencies change
@reactive
def TEAM_CAPACITY():
    return sum(member.hours for member in Team.ACTIVE)

# Automatically recalculates when Team.ACTIVE changes

The Transformation:

Computed variables transform your AI from a passive responder to an active analyst. Instead of “What’s the deadline?” followed by manual calculation, you get “We have 23 days until launch, we’re 78% complete, and at current velocity, we’ll finish 3 days early.”

CFT-PROJ-001_TASKMASTER-v1.0.txt
├── PROJECT_META (identification)
├── PROJECT_INSTRUCTIONS (rules)
├── PROJECT_VARIABLES (your database) ← THIS IS WHERE PERSISTENCE LIVES
├── PROJECT_FUNCTIONS (logic)
└── PROJECT_OBJECTS (entities)

# These live only during the current chat
current_task = "Update documentation"
temp_calculation = 42
user_input = "latest requirements"

# Gone when chat ends - DON'T put these in PROJECT_VARIABLES

# In PROJECT_VARIABLES section - survives forever
PROJECT_CONFIG = {
    "version": "2.1.0",
    "environment": "production",
    "features_enabled": ["dark_mode", "api_v2", "analytics"]
}

TEAM_MEMBERS = {
    "sarah": {"role": "Lead", "since": "2024-01-15"},
    "mike": {"role": "Backend", "since": "2024-03-20"}
}

# Available in every future chat session

# In CFT-SHARED-VARIABLES.txt - accessible by all projects
COMPANY_CONSTANTS = {
    "name": "InnovateTech Solutions",
    "founded": "2019",
    "headquarters": "San Francisco"
}

SHARED_RESOURCES = {
    "design_system": "https://design.innovatetech.io",
    "api_docs": "https://docs.innovatetech.io",
    "brand_guidelines": "v2.3"
}

# Reference from any project: SHARED.COMPANY_CONSTANTS.name

Variables persist. Context survives. No re-explanation needed.

# git diff CFT-PROJ-001_TASKMASTER-v1.0.txt

- TEAM_SIZE = 8
+ TEAM_SIZE = 10

- "features_enabled": ["dark_mode", "api_v2"]
+ "features_enabled": ["dark_mode", "api_v2", "analytics", "export"]

+ TEAM_MEMBERS.jennifer = {
+     "role": "QA Lead",
+     "since": "2025-07-01",
+     "expertise": ["automation", "performance"]
+ }

Track changes. Review updates. Rollback mistakes. It’s just text.

Text files handle more than you’ll ever need.

Instead: Store references, IDs, or non-sensitive metadata that your AI can use to understand context without exposing sensitive data.

The Persistence Promise:

Every variable you define today will be there tomorrow. No servers to maintain. No databases to backup. No sync issues. Just text that remembers, in a format that will still work in 10 years.

# Document WHY and WHEN
LAUNCH_METRICS = {
    "target_date": "2025-03-15",  # Added: 2025-01-27 - Q1 product launch
    "success_criteria": {
        "users": 1000,
        "revenue": 50000,
        "nps_score": 40
    }
}

# Keep related variables together
SPRINT_23 = {
    "status": "active",        # Updated: 2025-01-27
    "progress": 65,            # Updated: 2025-01-26
    "blockers": ["API redesign", "Auth service"],
    "last_updated": "2025-01-27"
}

# Mark when updates are needed
CONFIG_2024 = {
    "status": "legacy",
    "migration_notes": "Update to CONFIG_2025 by Q2",
    "still_used_by": ["reporting_system", "analytics"]
}

# Clear deprecation path
OLD_PRICING = {
    "_deprecated": True,
    "_deprecated_date": "2025-01-15",
    "_use_instead": "PRICING_TIERS",
    "_remove_after": "2025-06-01",
    "data": {...}  # Keep data for compatibility
}

2. Thou Shalt Document Purpose
Every variable needs a “why” – use comments liberally3. Thou Shalt Group Related Variables
Team.Members.SARAH beats scattered sarah_role, sarah_email

4. Thou Shalt Not Duplicate
One source of truth – no PROJECT_NAME and project_title

5. Thou Shalt Version Appropriately
CONFIG_2025 not CONFIG_NEW or CONFIG_LATEST

6. Thou Shalt Handle Missing Data
Default values prevent crashes

7. Thou Shalt Update Timestamps
Track when critical data changes

8. Thou Shalt Not Store Secrets
No passwords, API keys, or sensitive data

9. Thou Shalt Clean Regularly
Archive or remove unused variables quarterly

10. Thou Shalt Test Changes
Verify variable updates don’t break dependencies

CONFIG = {
    "default": {
        "timeout": 30,
        "retry": 3,
        "cache": True
    },
    "environments": {
        "dev": {"timeout": 60, "debug": True},
        "staging": {"cache": False},
        "prod": {"retry": 5, "monitoring": True}
    }
}

# Usage: merge default + environment specific

PROJECT_STATUS = {
    "phase": "beta",
    "health": "yellow",  # green, yellow, red
    "last_updated": "2025-01-27",
    "update_frequency": "daily",
    "next_milestone": {
        "name": "Public Launch",
        "date": "2025-03-15",
        "confidence": 0.85
    }
}

BUDGET_HISTORY = {
    "current": 125000,
    "changes": [
        {"date": "2025-01-01", "from": 100000, "to": 125000, "reason": "Q1 expansion"},
        {"date": "2024-10-01", "from": 75000, "to": 100000, "reason": "Series A"}
    ],
    "approvers": ["CFO", "CEO"],
    "next_review": "2025-04-01"
}

# Started simple (Month 1)
TEAM_SIZE = 3
RUNWAY_MONTHS = 18

# Evolved with structure (Month 6)
COMPANY = {
    "metrics": {
        "team_size": 8,
        "runway_months": 14,
        "burn_rate": 45000,
        "mrr": 12000
    },
    "milestones": {
        "seed_raised": "2024-06-01",
        "first_customer": "2024-09-15",
        "break_even": "2025-06-01 (projected)"
    }
}

# Benefit: AI now understands business context for strategic decisions

Challenge: 200+ spreadsheets, 50+ team members, constant confusionSolution: Migrated to CRAFT Variables over 3 months
• Week 1-4: Core team structure and roles
• Week 5-8: Project statuses and timelines
• Week 9-12: Metrics and KPIs

Result:
85% reduction in status meetings,
3x faster onboarding,
Zero “what’s the status?” interruptions

The Golden Rule:

If you find yourself explaining something to AI more than twice, it should be a variable. If you find yourself updating a variable more than once a day, it should be computed.

# Data Type defines the structure
TeamMember = {
    "name": str,
    "role": str,
    "skills": list[str],
    "availability": float,  # hours per week
    "timezone": str
}

# Variables instantiate with real data
TEAM = {
    "Sarah": {
        "name": "Sarah Chen",
        "role": "Frontend Lead",
        "skills": ["React", "TypeScript", "System Design"],
        "availability": 40,
        "timezone": "PST"
    },
    "Marcus": {
        "name": "Marcus Wong",
        "role": "Backend Architect",
        "skills": ["Python", "PostgreSQL", "Microservices"],
        "availability": 35,
        "timezone": "PST"
    }
}

# Validation using both
def validate_team_member(member_data):
    """Ensure member matches TeamMember type"""
    required_fields = TeamMember.keys()
    for field in required_fields:
        if field not in member_data:
            #AI->H::Error: (Missing required field: {field})
            return False
    return True

# Dynamic type creation from variables
def create_skill_matrix():
    """Generate skill coverage from team variables"""
    skill_matrix = {}
    for member, data in TEAM.items():
        for skill in data["skills"]:
            if skill not in skill_matrix:
                skill_matrix[skill] = []
            skill_matrix[skill].append(member)
    return skill_matrix

SKILL_COVERAGE = create_skill_matrix()
# Result: {"React": ["Sarah"], "Python": ["Marcus"], ...}

# Configuration variables drive function behavior
DEPLOYMENT_CONFIG = {
    "environments": ["dev", "staging", "prod"],
    "approval_required": {"dev": False, "staging": True, "prod": True},
    "rollback_window": {"dev": 0, "staging": 3600, "prod": 7200}  # seconds
}

def deploy_to_environment(env_name, version):
    """Deploy with environment-specific rules"""
    if env_name not in DEPLOYMENT_CONFIG["environments"]:
        return {"error": "Unknown environment"}
    
    if DEPLOYMENT_CONFIG["approval_required"][env_name]:
        if not get_approval(CURRENT_USER, env_name):
            return {"error": "Approval required"}
    
    result = perform_deployment(env_name, version)
    
    if result["success"]:
        DEPLOYMENT_HISTORY.append({
            "env": env_name,
            "version": version,
            "timestamp": datetime.now(),
            "deployed_by": CURRENT_USER["name"],
            "rollback_until": datetime.now() + 
                timedelta(seconds=DEPLOYMENT_CONFIG["rollback_window"][env_name])
        })
    
    return result

# Functions become aware of business rules through variables

class SprintTracker:
    def __init__(self):
        # Initialize from variables
        self.current_sprint = SPRINT_CONFIG["current_number"]
        self.team = TEAM
        self.velocity = METRICS["average_velocity"]
        
    def update_progress(self, task_id, status):
        """Update task and recalculate metrics"""
        TASKS[task_id]["status"] = status
        TASKS[task_id]["updated"] = datetime.now()
        TASKS[task_id]["updated_by"] = CURRENT_USER["name"]
        
        # Update computed variables
        self.recalculate_burndown()
        self.update_team_utilization()
        
    def get_status_report(self):
        """Generate report using multiple variables"""
        return {
            "sprint": self.current_sprint,
            "progress": self.calculate_progress(),
            "team_health": self.assess_team_health(),
            "risks": self.identify_risks(),
            "recommendations": self.generate_recommendations()
        }

# Object instance persists through variables
SPRINT_TRACKER = SprintTracker()

STANDUP_RECIPE = Recipe(
    name="Daily Standup Report",
    template="""
    Generate standup for {CURRENT_USER["name"]} on {CURRENT_DATE}
    
    Yesterday:
    - Review {COMPLETED_TASKS} from {YESTERDAY}
    - Note any {BLOCKERS} encountered
    
    Today:
    - List {ASSIGNED_TASKS} for {CURRENT_USER["id"]}
    - Priority: {SPRINT_GOALS[0]}
    
    Blockers:
    - Check {TEAM_BLOCKERS} affecting {CURRENT_USER["role"]}
    
    Team Context:
    - Sprint {CURRENT_SPRINT["number"]} - Day {SPRINT_DAY}
    - Velocity: {CURRENT_VELOCITY} vs target {TARGET_VELOCITY}
    """
)

# Recipe automatically uses current variable values
standup_report = STANDUP_RECIPE.execute()

# 1. Data Types define structure
ProjectStatus = DataType("project_status", 
    fields=["name", "phase", "health", "metrics", "risks"])

# 2. Variables store actual project data
PROJECTS = {
    "phoenix": {
        "name": "Project Phoenix",
        "phase": "beta",
        "health": "yellow",
        "metrics": {
            "completion": 78,
            "budget_used": 65,
            "team_morale": 8.2
        },
        "risks": ["timeline", "third_party_api"]
    }
}

# 3. Functions process the data
def analyze_project_health(project_id):
    project = PROJECTS[project_id]
    score = calculate_health_score(project["metrics"])
    recommendations = generate_recommendations(project["risks"])
    return {"score": score, "recommendations": recommendations}

# 4. Objects maintain state
class ProjectMonitor:
    def __init__(self, project_id):
        self.project = PROJECTS[project_id]
        self.history = PROJECT_HISTORY[project_id]
        
    def update_status(self):
        # Updates variables and triggers notifications
        pass

# 5. Comments provide context
#AI->H::Context: (Monitoring {len(PROJECTS)} active projects)
#AI->H::Alert: (Project Phoenix health degraded to {PROJECTS["phoenix"]["health"]})

# Everything connected through variables!

# Variables define the business state
INVENTORY = {
    "SKU-1001": {"stock": 145, "reorder_point": 50, "supplier": "Acme"},
    "SKU-1002": {"stock": 23, "reorder_point": 30, "supplier": "Beta"}
}

ACTIVE_CAMPAIGNS = {
    "summer_sale": {
        "discount": 0.25,
        "ends": "2025-08-31",
        "eligible_skus": ["SKU-1001", "SKU-1003"]
    }
}

ORDER_METRICS = {
    "today": {"count": 127, "revenue": 18549, "avg_cart": 146},
    "mtd": {"count": 3847, "revenue": 584920, "avg_cart": 152}
}

# Functions use variables for business logic
def process_order(cart_items):
    total = 0
    for item in cart_items:
        price = get_item_price(item["sku"])
        
        # Check campaigns
        for campaign, details in ACTIVE_CAMPAIGNS.items():
            if item["sku"] in details["eligible_skus"]:
                price *= (1 - details["discount"])
        
        # Update inventory
        INVENTORY[item["sku"]]["stock"] -= item["quantity"]
        
        # Check reorder
        if INVENTORY[item["sku"]]["stock"] < INVENTORY[item["sku"]]["reorder_point"]:
            trigger_reorder(item["sku"])
        
        total += price * item["quantity"]
    
    # Update metrics
    ORDER_METRICS["today"]["count"] += 1
    ORDER_METRICS["today"]["revenue"] += total
    
    return {"order_id": generate_id(), "total": total}

# AI Assistant can now answer:
# "What's our inventory status?"
# "Which items need reordering?"
# "How's the summer sale performing?"
# "What's today's revenue?"

Your AI now knows your project context permanently!

DEBUG_CHECKLIST = {
    "variable_not_found": [
        "Check variable name spelling",
        "Verify it's in PROJECT_VARIABLES section",
        "Ensure file is loaded in current session"
    ],
    "function_not_using_variable": [
        "Verify variable is in scope",
        "Check if variable name matches exactly",
        "Try explicit reference: PROJECT_VARIABLES['name']"
    ],
    "object_state_not_persisting": [
        "Store object state in variables",
        "Don't rely on instance attributes alone",
        "Update PROJECT_VARIABLES when state changes"
    ],
    "recipe_missing_context": [
        "Ensure variables are defined before recipe",
        "Check recipe template for {VARIABLE} syntax",
        "Verify variable names in template match exactly"
    ]
}

# When confused, ask:
# "Check DEBUG_CHECKLIST for my variable issue"

The Integration Promise:

Variables aren’t just another feature – they’re the backbone that makes every other CRAFT component smarter. When your Data Types, Functions, Objects, and Recipes all share the same variable context, your AI transforms from a tool into a knowledgeable partner who truly understands your business.

# Add to PROJECT_VARIABLES
from datetime import datetime

def get_project_age_days():
    """Calculate project age in days"""
    start = datetime.strptime(START_DATE, "%Y-%m-%d")
    return (datetime.now() - start).days

PROJECT_AGE_DAYS = get_project_age_days()

# Now you can ask:
# "How many days old is the project?"
# "Are we still in the first month?"

# Group related variables
TODO = {
    "high_priority": [
        "Set up development environment",
        "Create first feature"
    ],
    "low_priority": [
        "Update documentation",
        "Add tests"
    ],
    "completed": []
}

CONFIG = {
    "debug_mode": True,
    "auto_save": True,
    "theme": "dark"
}

# Usage:
# "What's in TODO.high_priority?"
# "Move 'Set up development environment' to TODO.completed"

TEAM = {
    "you": {
        "name": "Your Name",
        "roles": ["everything"],
        "skills": ["python", "ai", "craft"],
        "availability": "whenever needed"
    }
    # Ready to add team members later
}

COMMUNICATION = {
    "updates": "daily",
    "channels": ["ai-chat"],
    "style": "casual"
}

# Define a simple workflow
WORKFLOW = {
    "daily_standup": {
        "check": ["TODO.high_priority", "PROJECT_AGE_DAYS"],
        "update": ["TODO.completed"],
        "review": ["CONFIG.debug_mode"]
    }
}

# Morning routine:
# "Run daily_standup workflow"
# AI checks all specified variables and provides summary

# Just the basics
PROJECT_NAME = "CoolApp"
VERSION = "0.1"
STATUS = "development"

Goal: Get comfortable with persistence

# Group related data
PROJECT = {
    "name": "CoolApp",
    "version": "0.2",
    "features": ["login", "dashboard"]
}
METRICS = {
    "users": 10,
    "daily_active": 3
}

Goal: Discover organization patterns

# Add computed variables
def get_growth_rate():
    return METRICS["users"] / METRICS["initial_users"]

GROWTH_RATE = get_growth_rate()
HEALTH_SCORE = calculate_health()

Goal: Make variables work for you

# Connect with other CRAFT components
class Dashboard:
    def __init__(self):
        self.project = PROJECT
        self.metrics = METRICS
    
    def generate_report(self):
        return format_report(self.project, self.metrics)

Goal: Integrate with ecosystem

# Full system with hundreds of variables
COMPANY = {...}  # 50+ fields
PRODUCTS = {...}  # Multiple products
TEAM = {...}      # Growing team
METRICS = {...}   # Complex KPIs
WORKFLOWS = {...} # Automated processes

Goal: Run your business with Variables

# Copy-paste starter template
PROJECT_VARIABLES = {
    # Identity
    "PROJECT_NAME": "Your Project",
    "VERSION": "0.1.0",
    "START_DATE": "2025-01-27",
    
    # Team
    "TEAM": {
        "lead": "Your Name",
        "size": 1
    },
    
    # Status
    "CURRENT_PHASE": "planning",
    "NEXT_MILESTONE": "MVP",
    
    # Tasks
    "TODO": {
        "today": [],
        "this_week": [],
        "backlog": []
    },
    
    # Metrics
    "METRICS": {
        "progress": 0,
        "blockers": 0
    }
}

# Your first conversations:
# "What's PROJECT_NAME?"
# "Add 'Research competitors' to TODO.today"
# "Update METRICS.progress to 10"
# "Show me TODO.today"

The Promise of Persistence:

In 15 minutes, you’ve gone from zero to having a persistent memory system for your AI. In a week, you’ll wonder how you ever worked without it. In a month, you’ll have built an intelligent system that knows your business as well as you do.

Save Time
No more re-explaining context

Ensure Accuracy
One source of truth

Build Intelligence
Each session makes AI smarter

Enable Scale
10 to 1,000 variables easily

Foster Innovation
More thinking, less typing