How to prevent bad architecture from Cursor

1---
2description: Architecture rules - no global state
3globs: "src/**/*.ts,src/**/*.tsx"
4alwaysApply: true
5---
6
7## Global State Rules
8- NEVER use global variables or module-level mutable state
9- NEVER use the singleton pattern with module-level instances
10- NEVER store state in file-scoped 'let' variables
11- ALWAYS pass dependencies through function parameters or constructors
12- ALWAYS use React Context or Zustand for shared UI state
13- For configuration: use an imported config module (readonly)
14- For caching: use a dedicated cache service passed via DI
15- For logging: accept a logger parameter, do not import a global logger
16
17## Allowed Module-Level Declarations
18- const with primitive values or frozen objects
19- Type definitions and interfaces
20- Pure functions with no side effects
21- Readonly configuration objects

1// Cursor Chat prompt (Cmd+L, Ask mode):
2// @codebase Find all instances of global state in src/:
3// 1. Module-level 'let' or 'var' declarations
4// 2. Singleton patterns (getInstance())
5// 3. Mutable objects assigned at module scope
6// 4. Global event emitters or bus instances
7// 5. window.* or globalThis.* assignments
8// List each file, the pattern found, and suggest a modular alternative.

1// BEFORE (global singleton):
2let instance: DatabasePool | null = null;
3export function getPool(): DatabasePool {
4  if (!instance) {
5    instance = new DatabasePool(process.env.DATABASE_URL);
6  }
7  return instance;
8}
9
10// Select the code, press Cmd+K:
11// Refactor this global singleton into a factory function
12// that creates a pool instance. The instance should be
13// created once in the app entry point and passed to
14// services via constructor injection.
15
16// AFTER:
17export function createPool(url: string): DatabasePool {
18  return new DatabasePool(url);
19}
20
21// In app entry point:
22const pool = createPool(config.databaseUrl);
23const userService = new UserService(pool);

1// BEFORE:
2import { logger } from './globalLogger';
3export function processOrder(order: Order) {
4  logger.info('Processing order', { orderId: order.id });
5}
6
7// Cmd+K prompt:
8// Refactor to accept a logger parameter instead of
9// importing a global logger. Use an ILogger interface.
10
11// AFTER:
12import type { ILogger } from '@/types/interfaces';
13export function processOrder(order: Order, logger: ILogger) {
14  logger.info('Processing order', { orderId: order.id });
15}

1// Cursor Chat prompt (Cmd+L):
2// @src/services/orderService.ts Generate a test that:
3// 1. Creates a mock logger
4// 2. Calls processOrder with the mock
5// 3. Verifies the mock logger was called correctly
6// 4. Proves no global state is accessed
7
8import { processOrder } from './orderService';
9import type { ILogger } from '@/types/interfaces';
10
11const mockLogger: ILogger = {
12  info: vi.fn(),
13  error: vi.fn(),
14  warn: vi.fn(),
15};
16
17it('uses the injected logger', () => {
18  processOrder({ id: '123' } as Order, mockLogger);
19  expect(mockLogger.info).toHaveBeenCalledWith(
20    'Processing order', { orderId: '123' }
21  );
22});