Model-Driven Project Architecture, Dynamic Experimentation with AI

Feature Requests
1

Dear Cursor Team,

Cursor is uniquely positioned to redefine how teams combine architectural modeling, code generation, and iterative development.

This proposal is a logical continuation of my other request:
Automated Live Project Model — Architectural Memory and Integrity Control,
and like other user Dynamic AI-Assisted Development Workflow

The Problem

While Cursor already excels at code generation, context understanding, and rules-based editing, there are inherent limits to what any context window or set of manual rules can capture. Even with memory banks and custom rules, the AI can experience “amnesia” regarding the true structure, dependencies, and intent of a complex project—especially as it evolves over time. The lack of a persistent, centralized, and updateable architectural “skeleton” leads to lost context, inconsistent implementations, and missed opportunities for systematic experimentation or cross-language prototyping.

Vision

What if developers and the AI could collaboratively build and edit a project’s “skeleton”—a dynamic, graphical, or declarative model of its architecture—while allowing the AI to automatically generate and maintain the “meat” (the implementation) in any target technology or language?

Key Capabilities:

  • Graphical & Declarative Project Modeling:
    Developers and AI can visually craft or edit a living model of the project’s structure (e.g., modules, relationships, data flows, access rights). Think of this as an interactive diagramming tool or a declarative YAML/JSON model describing the shape of the system.
  • Automated Code Generation (“Flesh on the Skeleton”):
    AI can generate codebases based on the model in chosen frameworks or languages (e.g., React, Vue, Python, TypeScript, or even multiple variants). The same architectural skeleton can be implemented and compared in different stacks with minimal friction.
  • Instant Experimentation and “Non-Git” Rollbacks:
    Teams could iterate, experiment, and compare alternative implementations or architectural changes rapidly—rolling back to previous states, branching new experiments, and visualizing diffs—not just in code, but at the architectural level. This enables fast prototyping, safe “what-if” analysis, and true model-driven development, decoupled from traditional, static Git workflows.
  • AI-Aware Constraints and Permissions:
    The AI always reasons with the up-to-date project model, respects defined architectural boundaries, policies, and roles, and, if an action would violate a constraint, it notifies the user and requests approval—with a clear explanation of downstream impacts.
  • Model as Source of Truth:
    The architectural model becomes the persistent, editable, and explorable “source of truth,” ensuring both humans and AI share a holistic, evolving understanding of the system—overcoming context-loss issues inherent to current AI and memory-bank architectures.

Why This Matters

  • Unprecedented Consistency & Transparency:
    Centralizing architecture removes guesswork from both AI and developers, enabling predictable, maintainable, and explainable code evolution—especially in large or regulated projects.
  • Accelerated Multistack/Polyglot Development:
    By decoupling architecture from implementation details, teams can rapidly try new frameworks, migrate codebases, or compare strategies—without laborious manual translation or unclear impact.
  • Lowered Barrier for Experimentation & Onboarding:
    New contributors (whether human or AI) can quickly understand the big picture and safely experiment—all with rollback and comparison features unavailable in traditional Version Control Systems alone.

Example Concept (Project Model in YAML)

modules:
  users:
    description: Handles users & authentication
    depends_on: [auth, db]
    allowed_modify_roles: [lead, architect]
    critical: true
  payments:
    description: Payment processing system
    depends_on: [db, users, billing-gateway]
    allowed_modify_roles: [lead]
    critical: true
rules:
  - path: payments/*
    restrict_modification: true
    allowed_roles: [lead]
    explanation: "Changes affect all financial operations."
  - path: users/*
    require_review: true
global_constraints:
  ban_cross_module_coupling: true
  enforce_api_stability: true

Future Directions

  • Visual model editors and diagramming tools integrated in Cursor.
  • Language/framework “adapters” so a single model can output multiple implementations.
  • Integrated sandboxes and experiment management, allowing “branching” and “rollbacks” of architectural states.
  • Deep integration with testing, CI/CD, and external documentation—from model to implementation and back.

I believe this vision is entirely achievable—especially given Cursor’s already robust foundation, resourcefulness, and technical ambition. It would set a new standard for AI-assisted, model-driven, experiment-friendly development environments.